td engine 统计数据整合

neim-biz/src/main/java/com/jiayue/biz/job/AirDensityJob.java

@@ -1,19 +1,24 @@
 package com.jiayue.biz.job;
 
 import cn.hutool.core.date.DateTime;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.jiayue.biz.domain.*;
+import com.jiayue.biz.mapper.ProphaseAnemometryDataMapper;
+import com.jiayue.biz.mapper.ProphaseWeatherDataMapper;
 import com.jiayue.biz.service.EquipmentAttributeService;
 import com.jiayue.biz.service.WindTowerDataParentTableService;
 import com.jiayue.biz.service.impl.*;
 import com.jiayue.biz.util.DateTimeUtil;
 import com.jiayue.common.utils.DateUtil;
 import io.undertow.util.DateUtils;
+import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 
+import java.sql.Timestamp;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
@@ -21,32 +26,30 @@ import java.util.Map;
 @Slf4j
 @Service
 @EnableScheduling
+@AllArgsConstructor
 public class AirDensityJob {
-    @Autowired
+
     private final WindTowerCalculationDataServiceImpl windTowerCalculationDataService;
-    @Autowired
+
     private final WindTowerInfoServiceImpl windTowerInfoService;
-    @Autowired
+
     private final WindDirectionStatisticsDataServiceImpl windDirectionStatisticsDataService;
-    @Autowired
+
     private final EquipmentAttributeService equipmentAttributeService;
-    @Autowired
+
     private final StatisticsSituationServiceImpl statisticsSituationService;
-    @Autowired
+
     private final WindTowerDataParentTableService windTowerDataParentTableService;
 
-    public AirDensityJob(WindTowerCalculationDataServiceImpl windTowerCalculationDataService, WindTowerInfoServiceImpl windTowerInfoService, WindDirectionStatisticsDataServiceImpl windDirectionStatisticsDataService, EquipmentAttributeService equipmentAttributeService, StatisticsSituationServiceImpl statisticsSituationService, WindTowerDataParentTableService windTowerDataParentTableService) {
-        this.windTowerCalculationDataService = windTowerCalculationDataService;
-        this.windTowerInfoService = windTowerInfoService;
-        this.windDirectionStatisticsDataService = windDirectionStatisticsDataService;
-        this.equipmentAttributeService = equipmentAttributeService;
-        this.statisticsSituationService = statisticsSituationService;
-        this.windTowerDataParentTableService = windTowerDataParentTableService;
-    }
+    private final ProphaseAnemometryDataMapper prophaseAnemometryDataMapper;
+
+    private final ProphaseWeatherDataMapper prophaseWeatherDataMapper;
+
+
 
 //    @Scheduled(cron = "0 0 15 * * ?")
     //@Scheduled(cron = "0 0/1 * * * ?")
-    public void AirDensityCalculation() {
+    /*public void AirDensityCalculation1() {
         List<WindTowerInfo> windTowerInfoList = windTowerInfoService.list();
         // 统计概述信息
         List<StatisticsSituation> statisticsSituations = statisticsSituationService.list();
@@ -75,13 +78,22 @@ public class AirDensityJob {
                     sevenDate = time;
                 }
             }
+            //实时数据
             List<Map<String, Object>> maps = windTowerDataParentTableService.selectDataByBetweenTimeAndEquipmetId(startTime, endTime, windTowerInfo.getEquipmentNo());
+            //风数据查询
+            List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectList(Wrappers.<ProphaseAnemometryData>lambdaQuery()
+                    .eq(ProphaseAnemometryData::getEquipmentId, windTowerInfo.getEquipmentNo())
+                    .le(ProphaseAnemometryData::getTs, new Timestamp(endTime.getTime()))
+                    .ge(ProphaseAnemometryData::getTs, new Timestamp(startTime.getTime())));
+            //环境数据查询
+            List<ProphaseWeatherData> prophaseWeatherDataList = prophaseWeatherDataMapper.selectPublicData(windTowerInfo.getEquipmentNo(), new Timestamp(startTime.getTime()), new Timestamp(endTime.getTime()));
             //统计数据
             List<WindTowerCalculationData> windTowerCalculationDataList = windTowerCalculationDataService.getByBetweenTimeAndEquipmentId(startTime, endTime, windTowerInfo.getEquipmentNo());
             //小时平均风速风功率密度
-            windTowerCalculationDataService.calculateWindPowerDensity(sevenDate.getTime(), endDate.getTime(), windTowerInfo.getEquipmentNo(), maps, equipmentAttributeList, windTowerCalculationDataList);
+            windTowerCalculationDataService.calculateWindPowerDensity(sevenDate.getTime(), endDate.getTime(), windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList,prophaseWeatherDataList, equipmentAttributeList, windTowerCalculationDataList);
             //每小时风切变指数
             windTowerCalculationDataService.calculateWindPowerShear(sevenDate, endDate, windTowerInfo.getEquipmentNo(), maps, windTowerCalculationDataList);
+//            windTowerCalculationDataService.calculateWindPowerShear(sevenDate, endDate, windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList, windTowerCalculationDataList);
             //日平均温度
             windTowerCalculationDataService.tDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), maps, equipmentAttributeList);
             //日平均气压
@@ -156,5 +168,129 @@ public class AirDensityJob {
 
 
         }
+    }*/
+
+    //    @Scheduled(cron = "0 0 15 * * ?")
+    public void AirDensityCalculation() {
+        List<WindTowerInfo> windTowerInfoList = windTowerInfoService.list();
+        // 统计概述信息
+        List<StatisticsSituation> statisticsSituations = statisticsSituationService.list();
+        // 设备属性信息
+        List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeService.list();
+        //前7天
+        Date startDate = DateTimeUtil.getDayStartTime(new Date().getTime() - 60 * 60 * 24 * 1000 * 8);
+        //前一天23点59分
+//        Date endDate = DateTimeUtil.getDayLastTime(new Date().getTime() - 60 * 60 * 24 * 1000);
+        Date endDate = DateTimeUtil.getDayLastTime(1666195200000l);
+        //传入时间的月初
+        Date startMonthDate = DateTimeUtil.beginOfMonth(new Date());
+        //传入时间的月末
+        Date endMonthDate = DateTimeUtil.endOfMonth(new Date());
+        long yesterday = new Date().getTime() - 1000 * 60 * 60 * 24;//昨天
+        Date startTime = DateTimeUtil.getDayStartTime(DateTimeUtil.getYearDay(yesterday).getTime());
+        Date endTime = DateTimeUtil.getDayLastTime(yesterday);
+        for (WindTowerInfo windTowerInfo : windTowerInfoList) {
+            Date sevenDate = startDate;
+            //获取最后一条数据
+            WindTowerCalculationData lastData = windTowerCalculationDataService.getLastDataCalculation(windTowerInfo.getEquipmentNo());
+            //获取统计数据最后一天的数据时间第二天的 00 点
+            if(lastData != null){
+                Date time = new Date(DateTimeUtil.getDayLastTime(lastData.getTime().getTime()).getTime() + 1);
+                //如果最后一条统计数据的时间小于7天之前的时间 就拿
+                if (time.getTime() < startDate.getTime()) {
+                    sevenDate = time;
+                }
+            }
+            //实时数据
+//            List<Map<String, Object>> maps = windTowerDataParentTableService.selectDataByBetweenTimeAndEquipmetId(startTime, endTime, windTowerInfo.getEquipmentNo());
+            //风数据查询
+            List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectList(Wrappers.<ProphaseAnemometryData>lambdaQuery()
+                    .eq(ProphaseAnemometryData::getEquipmentId, windTowerInfo.getEquipmentNo())
+                    .le(ProphaseAnemometryData::getTs, new Timestamp(endTime.getTime()))
+                    .ge(ProphaseAnemometryData::getTs, new Timestamp(startTime.getTime())));
+            //环境数据查询
+            List<ProphaseWeatherData> prophaseWeatherDataList = prophaseWeatherDataMapper.selectPublicData(windTowerInfo.getEquipmentNo(), new Timestamp(startTime.getTime()), new Timestamp(endTime.getTime()));
+            //统计数据
+            List<WindTowerCalculationData> windTowerCalculationDataList = windTowerCalculationDataService.getByBetweenTimeAndEquipmentId(startTime, endTime, windTowerInfo.getEquipmentNo());
+            //小时平均风速风功率密度
+            windTowerCalculationDataService.calculateWindPowerDensity(sevenDate.getTime(), endDate.getTime(), windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList,prophaseWeatherDataList, equipmentAttributeList, windTowerCalculationDataList);
+            //每小时风切变指数
+//            windTowerCalculationDataService.calculateWindPowerShear(sevenDate, endDate, windTowerInfo.getEquipmentNo(), maps, windTowerCalculationDataList);
+            windTowerCalculationDataService.calculateWindPowerShear(sevenDate, endDate, windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList, windTowerCalculationDataList);
+            //日平均温度
+            windTowerCalculationDataService.tDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), prophaseWeatherDataList, equipmentAttributeList);
+            //日平均气压
+            windTowerCalculationDataService.paDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), prophaseWeatherDataList, equipmentAttributeList);
+            //日平均空气密度
+            windTowerCalculationDataService.airDensityDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), prophaseWeatherDataList, equipmentAttributeList, windTowerCalculationDataList);
+            //日平均湍流
+            windTowerCalculationDataService.turbulenceDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList, windTowerCalculationDataList);
+            //日平均风速
+            windTowerCalculationDataService.wsDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+            //日平均风切变
+            windTowerCalculationDataService.shearDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+            //日平均风功率密度
+            windTowerCalculationDataService.wpdDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+            //日平均风速标差
+            windTowerCalculationDataService.calculateStaDay(sevenDate, endDate, windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
+
+            //如果结束时间和数据统计的时间相差大于30天就分割月份进行计算
+            if (endDate.getTime() - sevenDate.getTime() > 86400000L * 30) {
+                List<Long> dateTime = DateTimeUtil.getIntervalTimeByMonth(DateTimeUtil.beginOfMonth(sevenDate), DateTimeUtil.beginOfMonth(endTime));
+                for (Long l : dateTime) {
+                    //月平均风速
+                    windTowerCalculationDataService.wsMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+                    //月平均风功率密度
+                    windTowerCalculationDataService.wpdMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+                    //月平均湍流
+                    windTowerCalculationDataService.turbulenceMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+                    //月平均空气密度
+                    windTowerCalculationDataService.airDensityMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList);
+                    //月最大风速
+                    windTowerCalculationDataService.wsMaxMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
+                    //月平均风切变
+                    windTowerCalculationDataService.shearMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+                    //月平均风速标差
+                    windTowerCalculationDataService.staMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
+                    //月玫瑰图
+                    windDirectionStatisticsDataService.roseMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList,prophaseWeatherDataList, equipmentAttributeList);
+                    //月平均环境数据
+                    windTowerCalculationDataService.environmentData(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerInfo.getEquipmentNo(), prophaseWeatherDataList, equipmentAttributeList);
+                    //空气密度月逐时
+                    windTowerCalculationDataService.airDensityMonth(windTowerInfo.getEquipmentNo(), DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), prophaseWeatherDataList);
+                    //湍流月逐时
+                    windTowerCalculationDataService.turbulenceHourForMonth(windTowerInfo.getEquipmentNo(), DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
+
+                }
+            } else {
+                //空气密度月逐时
+                windTowerCalculationDataService.airDensityMonth(windTowerInfo.getEquipmentNo(), startMonthDate, endMonthDate, prophaseWeatherDataList);
+                //湍流月逐时
+                windTowerCalculationDataService.turbulenceHourForMonth(windTowerInfo.getEquipmentNo(), startMonthDate, endMonthDate, prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
+                //月平均空气密度
+                windTowerCalculationDataService.airDensityMonth(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList);
+                //月平均湍流
+                windTowerCalculationDataService.turbulenceMonth(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+                //月平均风速
+                windTowerCalculationDataService.wsMonth(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+                //月平均风功率密度
+                windTowerCalculationDataService.wpdMonth(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+                //月最大风速
+                windTowerCalculationDataService.wsMaxMonth(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
+                //月平均风切变
+                windTowerCalculationDataService.shearMonth(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
+                //月平均风速标差
+                windTowerCalculationDataService.staMonth(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
+                //月环境数据 温湿压最大最小平均
+                windTowerCalculationDataService.environmentData(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), prophaseWeatherDataList, equipmentAttributeList);
+                // 统计概述
+                statisticsSituationService.statisticsSituation(windTowerInfo, statisticsSituations, equipmentAttributeList);
+                // 月玫瑰图
+                windDirectionStatisticsDataService.roseMonth(startMonthDate, endMonthDate, windTowerInfo.getEquipmentNo(), prophaseAnemometryDataList,prophaseWeatherDataList, equipmentAttributeList);
+            }
+
+
+        }
     }
+
 }

neim-biz/src/main/java/com/jiayue/biz/job/WindTowerCalculationDataJob.java

@@ -49,7 +49,7 @@ public class WindTowerCalculationDataJob {
             for (WindTowerInfo windTowerInfo : windTowerInfoList) {
                 List<WindTowerCalculationData> windTowerCalculationDataList = windTowerCalculationDataService.getByBetweenTimeAndEquipmentId(new Date(startTime), new Date(endTime), windTowerInfo.getEquipmentNo());
                 List<Map<String, Object>> maps = windTowerDataParentTableService.selectDataByBetweenTimeAndEquipmetId(new Date(startTime), new Date(endTime), windTowerInfo.getEquipmentNo());
-                windTowerCalculationDataService.calculateWindPowerDensity(startTime, endTime, windTowerInfo.getEquipmentNo(), maps, list,windTowerCalculationDataList);
+//                windTowerCalculationDataService.calculateWindPowerDensity(startTime, endTime, windTowerInfo.getEquipmentNo(), maps, list,windTowerCalculationDataList);
             }
 
         } catch (Exception e) {

neim-biz/src/main/java/com/jiayue/biz/mapper/ProphaseWeatherDataMapper.java

@@ -47,7 +47,7 @@ public interface ProphaseWeatherDataMapper extends BaseMapper<ProphaseWeatherDat
     @Select("SELECT t1.ts,t1.air_density FROM weather_${equipmentId} t1 where  t1.ts >= #{startTime} and t1.ts <= #{endTime}")
     List<ProphaseWeatherData> selectAir(@Param("equipmentId") String equipmentId, @Param("startTime") Timestamp startTime, @Param("endTime") Timestamp endTime);
 
-    @Select("select first (*) from nerp_db.weather_#{equipmentId}")
+    @Select("select first (ts) from nerp_db.weather_#{equipmentId}")
     List<Entity> getFirstData(@Param("equipmentId") String equipmentId);
     @Select("select last (ts) from nerp_db.weather_#{equipmentId}")
     List<Entity> getLastData(@Param("equipmentId") String equipmentId);

neim-biz/src/main/java/com/jiayue/biz/service/WindTowerCalculationDataService.java

@@ -2,6 +2,8 @@ package com.jiayue.biz.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.jiayue.biz.domain.EquipmentAttribute;
+import com.jiayue.biz.domain.ProphaseAnemometryData;
+import com.jiayue.biz.domain.ProphaseWeatherData;
 import com.jiayue.biz.domain.WindTowerCalculationData;
 
 import java.util.List;
@@ -11,7 +13,7 @@ import java.util.Map;
 public interface WindTowerCalculationDataService extends IService<WindTowerCalculationData> {
 
     //计算风功率密度
-    void calculateWindPowerDensity(Long startTime, Long endTime, String equipmentNo, List<Map<String, Object>> windTowerDataParentTableList, List<EquipmentAttribute> equipmentAttributeList,List<WindTowerCalculationData> windTowerCalculationDataList);
+    void calculateWindPowerDensity(Long startTime, Long endTime, String equipmentNo, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerCalculationData> windTowerCalculationDataList);
 
     List getWindShearByEqidAndAverageAndTime(Long time, String height, String eqId);
 

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

@@ -4,7 +4,10 @@ package com.jiayue.biz.service.impl;
 import cn.hutool.core.util.ZipUtil;
 import cn.hutool.poi.excel.ExcelReader;
 import cn.hutool.poi.excel.ExcelUtil;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.jiayue.biz.domain.*;
+import com.jiayue.biz.mapper.ProphaseAnemometryDataMapper;
+import com.jiayue.biz.mapper.ProphaseWeatherDataMapper;
 import com.jiayue.biz.service.DataRecalculationService;
 import com.jiayue.biz.service.EquipmentAttributeService;
 import com.jiayue.biz.service.WindTowerDataChildTableService;
@@ -12,6 +15,7 @@ import com.jiayue.biz.util.DateTimeUtil;
 import com.jiayue.biz.util.FileUtil;
 import com.jiayue.common.core.domain.AjaxResult;
 import com.jiayue.common.utils.file.FileUtils;
+import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.poi.xssf.streaming.SXSSFRow;
 import org.apache.poi.xssf.streaming.SXSSFSheet;
@@ -22,6 +26,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.io.*;
+import java.sql.Timestamp;
 import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -34,34 +39,28 @@ import java.util.stream.Collectors;
  */
 @Slf4j
 @Service
+@AllArgsConstructor
 public class DataRecalculationImpl implements DataRecalculationService {
-    @Autowired
+
     private final WindTowerDataParentTableServiceImpl windTowerDataParentTableService;
-    @Autowired
+
     private final WindTowerDataChildTableService windTowerDataChildTableService;
 
     private final WindTowerInfoServiceImpl windTowerInfoService;
     private final WindTowerCalculationDataServiceImpl windTowerCalculationDataService;
-    @Autowired
+
     private final WindDirectionStatisticsDataServiceImpl windDirectionStatisticsDataService;
-    @Autowired
+
     private final EquipmentAttributeService equipmentAttributeService;
-    @Autowired
+
     private final StatisticsSituationServiceImpl statisticsSituationService;
 
+    private AnalysisDataImpl analysisData;
+
+    private final ProphaseWeatherDataMapper prophaseWeatherDataMapper;
+    private final ProphaseAnemometryDataMapper prophaseAnemometryDataMapper;
 
-    @Autowired
-    AnalysisDataImpl analysisData;
 
-    public DataRecalculationImpl(WindTowerDataParentTableServiceImpl windTowerDataParentTableService, WindTowerDataChildTableService windTowerDataChildTableService, WindTowerInfoServiceImpl windTowerInfoService, WindTowerCalculationDataServiceImpl windTowerCalculationDataService, WindDirectionStatisticsDataServiceImpl windDirectionStatisticsDataService, EquipmentAttributeService equipmentAttributeService, StatisticsSituationServiceImpl statisticsSituationService) {
-        this.windTowerDataParentTableService = windTowerDataParentTableService;
-        this.windTowerDataChildTableService = windTowerDataChildTableService;
-        this.windTowerInfoService = windTowerInfoService;
-        this.windTowerCalculationDataService = windTowerCalculationDataService;
-        this.windDirectionStatisticsDataService = windDirectionStatisticsDataService;
-        this.equipmentAttributeService = equipmentAttributeService;
-        this.statisticsSituationService = statisticsSituationService;
-    }
 
     public void teset() {
 //    File file1 = MultipartFileToFile(file);
@@ -608,21 +607,27 @@ public class DataRecalculationImpl implements DataRecalculationService {
             List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeService.list();
             List<WindTowerCalculationData> windTowerCalculationDataList = windTowerCalculationDataService.getByBetweenTimeAndEquipmentId(startTime, endTime, equipmentNo);
             List<WindTowerInfo> windTowerInfoList = windTowerInfoService.getByEquipmentNo(equipmentNo);
-
+            //风数据查询
+            List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectList(Wrappers.<ProphaseAnemometryData>lambdaQuery()
+                    .eq(ProphaseAnemometryData::getEquipmentId, equipmentNo)
+                    .le(ProphaseAnemometryData::getTs, new Timestamp(endTime.getTime()))
+                    .ge(ProphaseAnemometryData::getTs, new Timestamp(startTime.getTime())));
+            //环境数据查询
+            List<ProphaseWeatherData> prophaseWeatherDataList = prophaseWeatherDataMapper.selectPublicData(equipmentNo, new Timestamp(startTime.getTime()), new Timestamp(endTime.getTime()));
             //把传入的时间按照日或月分割
             log.info("开始重新计算统计数据");
             //小时风功率密度和平均风速
-            windTowerCalculationDataService.calculateWindPowerDensity(startTime.getTime(), endTime.getTime(), equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList, windTowerCalculationDataList);
+            windTowerCalculationDataService.calculateWindPowerDensity(startTime.getTime(), endTime.getTime(), equipmentNo, prophaseAnemometryDataList,prophaseWeatherDataList, equipmentAttributeList, windTowerCalculationDataList);
             //小时风切变
-            windTowerCalculationDataService.calculateWindPowerShear(startTime, endTime, equipmentNo, windTowerDataParentTableMaps, windTowerCalculationDataList);
+            windTowerCalculationDataService.calculateWindPowerShear(startTime, endTime, equipmentNo, prophaseAnemometryDataList, windTowerCalculationDataList);
             //日平均温度
-            windTowerCalculationDataService.tDay(startTime, endTime, equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList);
+            windTowerCalculationDataService.tDay(startTime, endTime, equipmentNo, prophaseWeatherDataList, equipmentAttributeList);
             //日平均气压
-            windTowerCalculationDataService.paDay(startTime, endTime, equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList);
+            windTowerCalculationDataService.paDay(startTime, endTime, equipmentNo, prophaseWeatherDataList, equipmentAttributeList);
             //日平均湍流
-            windTowerCalculationDataService.turbulenceDay(startTime, endTime, equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList, windTowerInfoList, windTowerCalculationDataList);
+            windTowerCalculationDataService.turbulenceDay(startTime, endTime, equipmentNo, prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList, windTowerCalculationDataList);
             //日平均空气密度
-            windTowerCalculationDataService.airDensityDay(startTime, endTime, equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList, windTowerCalculationDataList);
+            windTowerCalculationDataService.airDensityDay(startTime, endTime, equipmentNo, prophaseWeatherDataList, equipmentAttributeList, windTowerCalculationDataList);
             //日平均风功率密度
             windTowerCalculationDataService.wpdDay(startTime, endTime, equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
             //日平均风切变
@@ -630,7 +635,7 @@ public class DataRecalculationImpl implements DataRecalculationService {
             //日平均风速
             windTowerCalculationDataService.wsDay(startTime, endTime, equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
             //日平均风速标差
-            windTowerCalculationDataService.calculateStaDay(startTime, endTime, equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList, windTowerInfoList);
+            windTowerCalculationDataService.calculateStaDay(startTime, endTime, equipmentNo, prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
 
             List<Long> dateTime = DateTimeUtil.getIntervalTimeByMonth(DateTimeUtil.beginOfMonth(startTime), DateTimeUtil.beginOfMonth(endTime));
             for (Long l : dateTime) {
@@ -643,19 +648,19 @@ public class DataRecalculationImpl implements DataRecalculationService {
                 //月平均空气密度
                 windTowerCalculationDataService.airDensityMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerCalculationDataList, equipmentAttributeList);
                 //月最大风速
-                windTowerCalculationDataService.wsMaxMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList, windTowerInfoList);
+                windTowerCalculationDataService.wsMaxMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
                 //月平均风切变
                 windTowerCalculationDataService.shearMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
                 //月平均风速标差
-                windTowerCalculationDataService.staMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList, windTowerInfoList);
+                windTowerCalculationDataService.staMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
                 //月玫瑰图
-                windDirectionStatisticsDataService.roseMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList);
+                windDirectionStatisticsDataService.roseMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, prophaseAnemometryDataList,prophaseWeatherDataList, equipmentAttributeList);
                 //月平均环境数据
-                windTowerCalculationDataService.environmentData(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerDataParentTableMaps, equipmentAttributeList);
+                windTowerCalculationDataService.environmentData(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, prophaseWeatherDataList, equipmentAttributeList);
                 //空气密度月逐时
-                windTowerCalculationDataService.airDensityMonth(equipmentNo, DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerDataParentTableMaps);
+                windTowerCalculationDataService.airDensityMonth(equipmentNo, DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), prophaseWeatherDataList);
                 //湍流月逐时
-                windTowerCalculationDataService.turbulenceHourForMonth(equipmentNo, DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), windTowerDataParentTableMaps, equipmentAttributeList, windTowerInfoList);
+                windTowerCalculationDataService.turbulenceHourForMonth(equipmentNo, DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
             }
             // 统计概述
             statisticsSituationService.statisticsSituation(windTowerInfoList.get(0), statisticsSituations, equipmentAttributeList);

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

@@ -381,14 +381,18 @@ public class RealTimeDisplayServiceImpl implements RealTimeDisplayService {
         for (WindTowerInfo windTowerInfo : windTowerInfoList) {
             HashMap<String, Object> hashMap = new HashMap<>();
             //获取最后一条数据
-            WindTowerDataParentTable lastData = windTowerDataParentTableService.getLastData(windTowerInfo.getEquipmentNo());
-            Date lastDataTime = lastData.getTime();
-            long startTime = DateTimeUtil.getDayStartTime(lastDataTime.getTime() - 86400000 * 7).getTime();
-            long endTime = DateTimeUtil.getDayLastTime(lastDataTime.getTime()).getTime();
-            hashMap.put("equipmentId", windTowerInfo.getEquipmentNo());
-            hashMap.put("startTime", startTime);
-            hashMap.put("endTime", endTime);
-            list.add(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;
     }

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

@@ -2,6 +2,8 @@ package com.jiayue.biz.service.impl;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.jiayue.biz.domain.EquipmentAttribute;
+import com.jiayue.biz.domain.ProphaseAnemometryData;
+import com.jiayue.biz.domain.ProphaseWeatherData;
 import com.jiayue.biz.domain.WindDirectionStatisticsData;
 import com.jiayue.biz.eunms.WindDirectionEnum;
 import com.jiayue.biz.mapper.WindDirectionStatisticsDataMapper;
@@ -80,22 +82,28 @@ public class WindDirectionStatisticsDataServiceImpl extends ServiceImpl<WindDire
     }
 
     /*玫瑰图*/
-    public void roseMonth(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> windTowerDataParentTableMaps, List<EquipmentAttribute> equipmentAttributeList) {
+    public void roseMonth(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList) {
         //该测风塔一年的数据
-        List<Map<String, Object>> windTowerDataParentTableListMap = windTowerDataParentTableMaps.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTime.getTime() &&
-                Long.parseLong(w.get("time").toString()) <= endTime.getTime()).collect(Collectors.toList());
+//        List<Map<String, Object>> windTowerDataParentTableListMap = windTowerDataParentTableMaps.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTime.getTime() &&
+//                Long.parseLong(w.get("time").toString()) <= endTime.getTime()).collect(Collectors.toList());
+
+        //风数据
+        List<ProphaseAnemometryData> anemometryDataList = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());
+        //环境数据
+        List<ProphaseWeatherData> weatherDataList = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= startTime.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());
+
 
         //获取所有层高
         String[] heights = windTowerInfoService.getByEquipmentNo(equipmentId).get(0).getWdHeights().split(",");
-        if (!windTowerDataParentTableListMap.isEmpty()) {
+        if (!anemometryDataList.isEmpty() && !weatherDataList.isEmpty()) {
             //风向玫瑰图
-            wdRose(startTime, endTime, equipmentId, windTowerDataParentTableListMap, equipmentAttributeList, heights);
+            wdRose(startTime, endTime, equipmentId, anemometryDataList, equipmentAttributeList, heights);
             //风功率玫瑰图
-            powerRose(startTime, endTime, equipmentId, windTowerDataParentTableListMap, equipmentAttributeList, heights);
+            powerRose(startTime, endTime, equipmentId, anemometryDataList, prophaseWeatherDataList, equipmentAttributeList, heights);
             //湍流玫瑰图
-            turRose(startTime, endTime, equipmentId, windTowerDataParentTableListMap, equipmentAttributeList, heights);
+            turRose(startTime, endTime, equipmentId, anemometryDataList, equipmentAttributeList, heights);
             //风切变玫瑰图
-            windShearRose(startTime, endTime, equipmentId, windTowerDataParentTableListMap, equipmentAttributeList, heights);
+            windShearRose(startTime, endTime, equipmentId, anemometryDataList, equipmentAttributeList, heights);
         } else {
             log.info("设备编号{}，{}月，玫瑰图计算失败，缺少测风塔数据^ ^", equipmentId, startTime.getMonth() + 1);
         }
@@ -106,23 +114,25 @@ public class WindDirectionStatisticsDataServiceImpl extends ServiceImpl<WindDire
     /**
      * 风向玫瑰图统计计算
      */
-    public void wdRose(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> windTowerDataParentTableMaps, List<EquipmentAttribute> equipmentAttributeList, String[] heights) {
+    public void wdRose(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> anemometryDataList, List<EquipmentAttribute> equipmentAttributeList, String[] heights) {
         ArrayList<WindDirectionStatisticsData> list = new ArrayList<>();
         try {
             for (String height : heights) {
                 String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(height + "monthWdRose")).collect(Collectors.toList()).get(0).getId();
                 //删除时间段所有数据
                 removeByStartTimeBetweenAndEquipmentIdAndEbId(new Date(startTime.getTime() - 1), endTime, equipmentId, ebIdMonth);
+                //筛选本层风数据
+                List<ProphaseAnemometryData> collect = anemometryDataList.stream().filter(a -> a.getLayerHeight().equals(height)).collect(Collectors.toList());
                 for (WindDirectionEnum value : WindDirectionEnum.values()) {
 
-                    List<Map<String, Object>> windTowerDataParentTableMap = CalculationUtil.getForHeightAndWindDirectionEnum(windTowerDataParentTableMaps, height, value);
-                    if (!windTowerDataParentTableMap.isEmpty()) {
+                    List<ProphaseAnemometryData> forHeightAndWindDirectionEnum = CalculationUtil.getForHeightAndWindDirectionEnum(collect, value);
+                    if (!forHeightAndWindDirectionEnum.isEmpty()) {
                         WindDirectionStatisticsData windDirectionStatisticsData = new WindDirectionStatisticsData();
                         windDirectionStatisticsData.setEbId(ebIdMonth);
                         windDirectionStatisticsData.setTime(startTime);
                         windDirectionStatisticsData.setEquipmentId(equipmentId);
                         windDirectionStatisticsData.setDirection(value.name());
-                        windDirectionStatisticsData.setValue(BigDecimal.valueOf(windTowerDataParentTableMap.size()));
+                        windDirectionStatisticsData.setValue(BigDecimal.valueOf(forHeightAndWindDirectionEnum.size()));
                         list.add(windDirectionStatisticsData);
                     }
                 }
@@ -138,20 +148,22 @@ public class WindDirectionStatisticsDataServiceImpl extends ServiceImpl<WindDire
     /**
      * 风功率玫瑰图统计计算
      */
-    public void powerRose(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> windTowerDataParentTableMaps, List<EquipmentAttribute> equipmentAttributeList, String[] heights) {
+    public void powerRose(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> anemometryDataList, List<ProphaseWeatherData> prophaseWeatherDataList,List<EquipmentAttribute> equipmentAttributeList, String[] heights) {
         ArrayList<WindDirectionStatisticsData> list = new ArrayList<>();
         try {
             for (String height : heights) {
                 String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(height + "monthPowerRose")).collect(Collectors.toList()).get(0).getId();
                 //删除时间段所有数据
                 removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebIdMonth);
+                List<ProphaseAnemometryData> collect = anemometryDataList.stream().filter(a -> a.getLayerHeight().equals(height)).collect(Collectors.toList());
                 for (WindDirectionEnum value : WindDirectionEnum.values()) {
                     //根据设备属性风向获取数据
-                    List<Map<String, Object>> windTowerDataParentTableMap = CalculationUtil.getForHeightAndWindDirectionEnum(windTowerDataParentTableMaps, height, value);
-                    if (!windTowerDataParentTableMap.isEmpty()) {
-                        List<BigDecimal> wsList = CalculationUtil.getWsForHeight(windTowerDataParentTableMap, height);
+//                    List<Map<String, Object>> windTowerDataParentTableMap = CalculationUtil.getForHeightAndWindDirectionEnum(anemometryDataList, value);
+                    List<ProphaseAnemometryData> forHeightAndWindDirectionEnum = CalculationUtil.getForHeightAndWindDirectionEnum(collect, value);
+                    if (!forHeightAndWindDirectionEnum.isEmpty()) {
+
                         //根据风向获取风能数
-                        BigDecimal bigDecimal = CalculationUtil.windEnergyDensity(windTowerDataParentTableMap, wsList,height);
+                        BigDecimal bigDecimal = CalculationUtil.windEnergyDensity(forHeightAndWindDirectionEnum, prophaseWeatherDataList);
                         // 数据集合
                         WindDirectionStatisticsData windDirectionStatisticsData = new WindDirectionStatisticsData();
                         windDirectionStatisticsData.setEbId(ebIdMonth);
@@ -175,7 +187,7 @@ public class WindDirectionStatisticsDataServiceImpl extends ServiceImpl<WindDire
     /**
      * 湍流玫瑰图统计计算
      */
-    public void turRose(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> windTowerDataParentTableMaps, List<EquipmentAttribute> equipmentAttributeList, String[] heights) {
+    public void turRose(Date startTime, Date endTime, String equipmentId,  List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, String[] heights) {
         BigDecimal zero = new BigDecimal(0);
         ArrayList<WindDirectionStatisticsData> list = new ArrayList<>();
         try {
@@ -183,16 +195,32 @@ public class WindDirectionStatisticsDataServiceImpl extends ServiceImpl<WindDire
                 String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(height + "monthTurRose")).collect(Collectors.toList()).get(0).getId();
                 //删除时间段所有数据
                 removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebIdMonth);
+                List<ProphaseAnemometryData> prophaseAnemometryData = prophaseAnemometryDataList.stream().filter(p -> p.getLayerHeight().equals(height)).collect(Collectors.toList());
                 for (WindDirectionEnum value : WindDirectionEnum.values()) {
-                    List<Map<String, Object>> windTowerDataParentTableMap = CalculationUtil.getForHeightAndWindDirectionEnum(windTowerDataParentTableMaps, height, value);
-                    if (!windTowerDataParentTableMap.isEmpty()) {
-                        List<BigDecimal> wsForHeight = CalculationUtil.getWsForHeight(windTowerDataParentTableMaps, height);
+//                    List<Map<String, Object>> windTowerDataParentTableMap = CalculationUtil.getForHeightAndWindDirectionEnum(windTowerDataParentTableMaps, height, value);
+                    List<ProphaseAnemometryData> heightAndWindDirectionEnum = CalculationUtil.getForHeightAndWindDirectionEnum(prophaseAnemometryData, value);
+
+
+                    if (!heightAndWindDirectionEnum.isEmpty()) {
+                        //获取指定层高风速数据
+                        List<BigDecimal> wsForHeight = heightAndWindDirectionEnum.stream().filter(h -> h.getWsAve() != null && h.getWsAve() != 0).map((ProphaseAnemometryData p) ->
+                                {
+                                    return CalculationUtil.getBigDecimal(p.getWsAve());
+                                }
+                        ).collect(Collectors.toList());
+
                         //删除值为null的数据
                         wsForHeight.removeAll(Collections.singletonList(null));
                         //平均风速
                         BigDecimal avgWindSpeed = CalculationUtil.getAvgWind(wsForHeight);
+                        //获取指定层高标差数据集合
+                        List<BigDecimal> staForHeight = heightAndWindDirectionEnum.stream().filter(h -> h.getWsSta() != null && h.getWsSta() != 0).map((ProphaseAnemometryData p) ->
+                                {
+                                    return CalculationUtil.getBigDecimal(p.getWsSta());
+                                }
+                        ).collect(Collectors.toList());
                         //平均风速标准差
-                        BigDecimal avgWindSpeedSta = CalculationUtil.getAvgWind(CalculationUtil.getWsStaForHeight(windTowerDataParentTableMaps, height));
+                        BigDecimal avgWindSpeedSta = CalculationUtil.getAvgWind(staForHeight);
                         // 湍流
                         BigDecimal bigDecimal = CalculationUtil.caTurbulenceIntensity(avgWindSpeedSta, avgWindSpeed);
                         // 数据集合
@@ -218,7 +246,7 @@ public class WindDirectionStatisticsDataServiceImpl extends ServiceImpl<WindDire
     /**
      * 风切变玫瑰图统计计算
      */
-    public void windShearRose(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> windTowerDataParentTableMaps, List<EquipmentAttribute> equipmentAttributeList, String[] heights) {
+    public void windShearRose(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> anemometryDataList, List<EquipmentAttribute> equipmentAttributeList, String[] heights) {
         ArrayList<WindDirectionStatisticsData> list = new ArrayList<>();
         //设置最小层高  数值越大越好
         int heightMin = 100;
@@ -239,7 +267,7 @@ public class WindDirectionStatisticsDataServiceImpl extends ServiceImpl<WindDire
             }
             for (String height : heights) {
                 //如果层高等于最小增高则跳出循环
-                if(height.equals(String.valueOf(heightMin))){
+                if (height.equals(String.valueOf(heightMin))) {
                     continue;
                 }
                 String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(height + "monthShearRose")).collect(Collectors.toList()).get(0).getId();
@@ -247,16 +275,30 @@ public class WindDirectionStatisticsDataServiceImpl extends ServiceImpl<WindDire
                 removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebIdMonth);
                 for (WindDirectionEnum value : WindDirectionEnum.values()) {
 
-                    List<Map<String, Object>> windTowerDataParentTableMap = CalculationUtil.getForHeightAndWindDirectionEnum(windTowerDataParentTableMaps, height, value);
-                    if (!windTowerDataParentTableMap.isEmpty()) {
+//                    List<Map<String, Object>> windTowerDataParentTableMap = CalculationUtil.getForHeightAndWindDirectionEnum(anemometryDataList, value);
+                    List<ProphaseAnemometryData> heightAndWindDirectionEnum = CalculationUtil.getForHeightAndWindDirectionEnum(anemometryDataList, value);
+                    if (!heightAndWindDirectionEnum.isEmpty()) {
+                        //获取指定层高风速数据
+                        List<BigDecimal> wsForHeight = heightAndWindDirectionEnum.stream().filter(h -> h.getWsAve() != null && h.getWsAve() != 0 && h.getLayerHeight().equals(height)).map((ProphaseAnemometryData p) ->
+                                {
+                                    return CalculationUtil.getBigDecimal(p.getWsAve());
+                                }
+                        ).collect(Collectors.toList());
                         //计算当前层高平均风速
-                        BigDecimal avgWindSpeed = CalculationUtil.getAvgWind(CalculationUtil.getWsForHeight(windTowerDataParentTableMap, height));
+                        BigDecimal avgWindSpeed = CalculationUtil.getAvgWind(wsForHeight);
+                        //获取指定最小层高风速数据
+                        int finalHeightMin = heightMin;
+                        List<BigDecimal> wsMinForHeight = heightAndWindDirectionEnum.stream().filter(h -> h.getWsAve() != null && h.getWsAve() != 0 && h.getLayerHeight().equals(finalHeightMin)).map((ProphaseAnemometryData p) ->
+                                {
+                                    return CalculationUtil.getBigDecimal(p.getWsAve());
+                                }
+                        ).collect(Collectors.toList());
                         //计算最小层高平均风速
-                        BigDecimal minAvgWindSpeed = CalculationUtil.getAvgWind(CalculationUtil.getWsForHeight(windTowerDataParentTableMap, Integer.toString(heightMin)));
+                        BigDecimal minAvgWindSpeed = CalculationUtil.getAvgWind(wsMinForHeight);
                         BigDecimal bigDecimal = new BigDecimal(-99);
-                        if(minAvgWindSpeed.compareTo(BigDecimal.ZERO) != 0){
+                        if (minAvgWindSpeed.compareTo(BigDecimal.ZERO) != 0) {
                             //计算风切变值
-                             bigDecimal = CalculationUtil.caWindShear(avgWindSpeed, minAvgWindSpeed, new BigDecimal(height), new BigDecimal(heightMin));
+                            bigDecimal = CalculationUtil.caWindShear(avgWindSpeed, minAvgWindSpeed, new BigDecimal(height), new BigDecimal(heightMin));
                         }
                         // 数据集合
                         WindDirectionStatisticsData windDirectionStatisticsData = new WindDirectionStatisticsData();

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

@@ -1,6 +1,7 @@
 package com.jiayue.biz.service.impl;
 
 import cn.hutool.core.convert.Convert;
+import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.jiayue.biz.conf.RequestDataHelper;
@@ -29,6 +30,7 @@ import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.DoubleStream;
 
 /**
  * 统计数据实现类
@@ -76,14 +78,13 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
     /**
      * 风功率密度和平均风速计算方法
      */
-    public void calculateWindPowerDensity(Long startTime, Long endTime, String eqNo, List<Map<String, Object>> windTowerDataParentTableList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerCalculationData> windTowerCalculationDataList) {
+    public void calculateWindPowerDensity(Long startTime, Long endTime, String eqNo, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerCalculationData> windTowerCalculationDataList) {
         //获取对应测风塔数据
-        List<Map<String, Object>> collect = windTowerDataParentTableList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTime && Long.parseLong(w.get("time").toString()) <= endTime && w.get("equipment_id").equals(eqNo)).collect(Collectors.toList());
+        List<ProphaseAnemometryData> anemometryDataList = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime && p.getTs().getTime() <= endTime).collect(Collectors.toList());
+        List<ProphaseWeatherData> weatherDataList = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= startTime && p.getTs().getTime() <= endTime).collect(Collectors.toList());
         long hour = 3600000L;
         List<WindTowerInfo> windTowerInfos = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, eqNo).list();
-
         String[] height = windTowerInfos.get(0).getHeights().split(",");
-
         //定义数据空集合用来装载 结果数据
         List<WindTowerCalculationData> list = new ArrayList<>();
         try {
@@ -98,9 +99,17 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                 for (long time = startTime; time <= endTime; time += hour) {
                     //过滤出对应测风塔数据
                     long finalTime = time;
-                    List<Map<String, Object>> filterList = collect.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= finalTime && Long.parseLong(w.get("time").toString()) <= finalTime + hour - 1000 && w.get("equipment_id").equals(eqNo)).collect(Collectors.toList());
+                    //风数据过滤
+                    List<ProphaseAnemometryData> anemometryData = anemometryDataList.stream().filter(w -> w.getTs().getTime() >= finalTime && w.getTs().getTime() <= finalTime + hour - 1000 && w.getLayerHeight().equals(h)).collect(Collectors.toList());
+                    //环境数据过滤
+                    List<ProphaseWeatherData> weatherData = weatherDataList.stream().filter(w -> w.getTs().getTime() >= finalTime && w.getTs().getTime() <= finalTime + hour - 1000).collect(Collectors.toList());
                     //根据层高获取所有风速数据
-                    List<BigDecimal> bigDecimals = CalculationUtil.getWsForHeight(filterList, h);
+                    List<BigDecimal> bigDecimals = anemometryData.stream().map((ProphaseAnemometryData p) -> {
+                        if (p.getWsAve() != null) {
+                            return BigDecimal.valueOf(p.getWsAve());
+                        }
+                        return BigDecimal.ZERO;
+                    }).collect(Collectors.toList());
 
                     //风速数据时所有计算的根本，无数据不计算
                     if (!bigDecimals.isEmpty()) {
@@ -108,7 +117,7 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                         if (bigDecimals.get(0) == null) {
                             continue;
                         }
-                        SpeedAndDensityDto speedAndDensityDto = getSpeedAndDensityDto(bigDecimals, filterList, h);
+                        SpeedAndDensityDto speedAndDensityDto = getSpeedAndDensityDto(bigDecimals, anemometryData, weatherData);
                         //保存风速
                         WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                         windTowerCalculationData.setTime(new Date(time));
@@ -143,14 +152,13 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * 获取风况数据（平均风速，风功率密度）
      *
      * @param bigDecimalList 风速数据
-     * @param mapList        风数据
      * @return
      */
-    public SpeedAndDensityDto getSpeedAndDensityDto(List<BigDecimal> bigDecimalList, List<Map<String, Object>> mapList, String height) {
+    public SpeedAndDensityDto getSpeedAndDensityDto(List<BigDecimal> bigDecimalList, List<ProphaseAnemometryData> anemometryData, List<ProphaseWeatherData> weatherData) {
 
         SpeedAndDensityDto speedAndDensityDto = new SpeedAndDensityDto();
         speedAndDensityDto.setWindSpeed(windSpeed(bigDecimalList));
-        speedAndDensityDto.setWindPowerDensity(CalculationUtil.windEnergyDensity(mapList, bigDecimalList, height));
+        speedAndDensityDto.setWindPowerDensity(CalculationUtil.windEnergyDensity(anemometryData, weatherData));
 
         return speedAndDensityDto;
     }
@@ -1117,7 +1125,6 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
     }
 
 
-
     /**
      * 计算日平均空气密度
      *
@@ -1125,13 +1132,11 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param endTime     结束时间
      * @param equipmentId 设备ID
      */
-    public void airDensityDay(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerCalculationData> windTowerCalculationDataList) {
+    public void airDensityDay(Date startTime, Date endTime, String equipmentId, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerCalculationData> windTowerCalculationDataList) {
 
         long startHour = startTime.getTime();
         long endHour = endTime.getTime();
         Long dayTime = 86400000L;
-        //所有数据
-        List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour && Long.parseLong(w.get("time").toString()) <= endHour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
         //空气密度属性
         EquipmentAttribute equipmentAttribute = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals("airDensity")).collect(Collectors.toList()).get(0);
         //删除时间段所有数据
@@ -1139,24 +1144,20 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
         ArrayList<WindTowerCalculationData> list = new ArrayList<>();
         try {
             for (long start1 = startHour; start1 < endHour; start1 = start1 + dayTime) {
-
                 //每天的结束时间
                 long start2 = start1 + dayTime - 1L;
-
                 BigDecimal airDensityDay = new BigDecimal(0);
                 long start = start1;
-                List<Map<String, Object>> collect1 = collect.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= start && Long.parseLong(w.get("time").toString()) <= start2 && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
-                for (Map<String, Object> map : collect1) {
-                    if (map.get("air_density") != null && !map.get("air_density").equals("")) {
-                        airDensityDay = airDensityDay.add(CalculationUtil.getBigDecimal(map.get("air_density")));
-                    }
+                List<ProphaseWeatherData> collect = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= start && p.getTs().getTime() <= start2).collect(Collectors.toList());
+                for (ProphaseWeatherData map : collect) {
+                    airDensityDay = airDensityDay.add(CalculationUtil.getBigDecimal(map.getAirDensity()));
                 }
                 //存平均值
-                if (!collect1.isEmpty()) {
+                if (!collect.isEmpty()) {
                     WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                     windTowerCalculationData.setEbId(equipmentAttribute.getId());
                     windTowerCalculationData.setTime(new Date(start1));
-                    windTowerCalculationData.setValue(airDensityDay.divide(new BigDecimal(collect1.size()), 2, RoundingMode.HALF_UP));
+                    windTowerCalculationData.setValue(airDensityDay.divide(new BigDecimal(collect.size()), 2, RoundingMode.HALF_UP));
                     windTowerCalculationData.setEquipmentId(equipmentId);
                     windTowerCalculationDataList.add(windTowerCalculationData);
                     list.add(windTowerCalculationData);
@@ -1182,11 +1183,14 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param endTime     结束时间
      * @param equipmentId 设备id
      */
-    public void wsMaxMonth(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
+    public void wsMaxMonth(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
 
         //获取时间段所有统计数据
-        List<Map<String, Object>> collects = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTime.getTime()
-                && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+//        List<Map<String, Object>> collects = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTime.getTime()
+//                && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+
+        List<ProphaseAnemometryData> collect = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());
+
         //获取所有层高
         String[] height = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights().split(",");
         ArrayList<WindTowerCalculationData> list = new ArrayList<>();
@@ -1196,16 +1200,13 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                 String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "maxwsMonth")).collect(Collectors.toList()).get(0).getId();
                 //删除时间段所有数据
                 removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebIdMonth);
-                //获取时间段所有风速数据
-                List<BigDecimal> maxList = CalculationUtil.getWsMaxForHeight(collects, h);
-                if (!collects.isEmpty()) {
-                    List<BigDecimal> collect = maxList.stream().sorted().collect(Collectors.toList());
-                    BigDecimal max = collect.get(collect.size() - 1);
+                if (!collect.isEmpty()) {
+                    BigDecimal max = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getLayerHeight().equals(h)).mapToDouble(ProphaseAnemometryData::getWsMax).sum());
                     WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                     windTowerCalculationData.setEbId(ebIdMonth);
                     windTowerCalculationData.setTime(startTime);
                     windTowerCalculationData.setEquipmentId(equipmentId);
-                    windTowerCalculationData.setValue(max);
+                    windTowerCalculationData.setValue(max.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP));
                     list.add(windTowerCalculationData);
                 } else {
                     log.info("设备编号{}，{}月，{}米层高月最大风速计算失败，缺少数据^ ^", equipmentId, startTime.getMonth() + 1, h);
@@ -1511,11 +1512,10 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param startTime              开始时间
      * @param endTime                结束时间
      * @param equipmentId            测风塔编号
-     * @param mapList                实时数据
      * @param equipmentAttributeList 属性表
      * @param windTowerInfoList      测风塔数据
      */
-    public void calculateStaDay(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
+    public void calculateStaDay(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
         ArrayList<WindTowerCalculationData> dataList = new ArrayList<>();
         long startHour = startTime.getTime();
         long endHour = endTime.getTime();
@@ -1529,29 +1529,15 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                 removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, equipmentAttributes.get(0).getId());
                 //每天循环
                 for (long time = startHour; time < endHour; time = time + Hour) {
-                    BigDecimal staSum = BigDecimal.ZERO;
-                    BigDecimal total = BigDecimal.ZERO;
                     long startDate = time;
                     //过滤一天的数据
-                    List<Map<String, Object>> mapList1 = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startDate
-                            && Long.parseLong(w.get("time").toString()) < startDate + Hour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
-                    for (Map<String, Object> map : mapList1) {
-                        String abnormal_type = "";
-                        //过滤异常值
-                        if (map.get("abnormal_type") != null) {
-                            abnormal_type = map.get("abnormal_type").toString();
-                        }
-                        if (map.get("ws_sta" + h) != null && (!abnormal_type.contains("wsSta" + h) || !abnormal_type.contains("ws_sta" + h))) {
-                            BigDecimal sta = CalculationUtil.getBigDecimal(map.get("ws_sta" + h));
-                            staSum = staSum.add(sta);
-                            total = total.add(BigDecimal.ONE);
-                        }
-                    }
-                    if (staSum.compareTo(BigDecimal.ZERO) != 0) {
+                    List<ProphaseAnemometryData> collect = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startDate && p.getTs().getTime() <= startDate + Hour && p.getLayerHeight().equals(h)).collect(Collectors.toList());
+                    BigDecimal staSum = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getWsSta() != null && c.getWsSta() != 0).mapToDouble(ProphaseAnemometryData::getWsSta).sum());
+                    if (collect.size() > 0) {
                         WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                         windTowerCalculationData.setEquipmentId(equipmentId);
                         windTowerCalculationData.setTime(new Date(startDate));
-                        windTowerCalculationData.setValue(staSum.divide(total, 2, RoundingMode.HALF_UP));
+                        windTowerCalculationData.setValue(staSum.divide(CalculationUtil.getBigDecimal(collect.size()), 2, RoundingMode.HALF_UP));
                         windTowerCalculationData.setEbId(equipmentAttributes.get(0).getId());
                         dataList.add(windTowerCalculationData);
                     } else {
@@ -1575,14 +1561,13 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param endTime     结束时间
      * @param equipmentId 设备id
      */
-    public void turbulenceDay(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList, List<WindTowerCalculationData> windTowerCalculationDataList) {
+    public void turbulenceDay(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList, List<WindTowerCalculationData> windTowerCalculationDataList) {
         long startHour = startTime.getTime();
         long endHour = endTime.getTime();
         long dayTime = 86400000L;
         String heights = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights();
         String[] heightAll = heights.split(",");
         //获取对应测风塔数据
-        List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour && Long.parseLong(w.get("time").toString()) <= endHour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
         ArrayList<WindTowerCalculationData> list = new ArrayList<>();
         try {
             for (String h : heightAll) {
@@ -1595,12 +1580,14 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                     long start2 = start1 + dayTime - 1L;
                     long start = start1 - 1;
 
-                    List<Map<String, Object>> maps = collect.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= start && Long.parseLong(w.get("time").toString()) <= start2 && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
-
+                    List<ProphaseAnemometryData> collect = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= start && p.getTs().getTime() <= start2 && p.getLayerHeight().equals(h)).collect(Collectors.toList());
+                    List<BigDecimal> wsList = new ArrayList<>();
+                    List<BigDecimal> staList = new ArrayList<>();
                     //过滤风速平均值
-                    List<BigDecimal> wsList = CalculationUtil.getWsForHeight(maps, h);
-                    //过滤风速标差值
-                    List<BigDecimal> staList = CalculationUtil.getWsStaForHeight(maps, h);
+                    for (ProphaseAnemometryData pro : collect) {
+                        wsList.add(CalculationUtil.getBigDecimal(pro.getWsAve()));
+                        staList.add(CalculationUtil.getBigDecimal(pro.getWsSta()));
+                    }
                     BigDecimal wsSum = BigDecimal.ZERO;
                     BigDecimal staSum = BigDecimal.ZERO;
                     for (BigDecimal ws : wsList) {
@@ -1900,36 +1887,25 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param startTime              开始时间
      * @param endTime                结束时间
      * @param equipmentId            设备Id
-     * @param mapList                实时数据
      * @param equipmentAttributeList 属性集合
      */
-    public void tDay(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList) {
+    public void tDay(Date startTime, Date endTime, String equipmentId, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList) {
         String ebId = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("tDay")).collect(Collectors.toList()).get(0).getId();
         long day = 86400000L;
         ArrayList<WindTowerCalculationData> list = new ArrayList<>();
         removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebId);
         try {
             for (long time = startTime.getTime(); time < endTime.getTime(); time += day) {
-                BigDecimal tsum = BigDecimal.ZERO;
                 long dayTime = time;
                 //过滤一天数据
-                List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= dayTime &&
-                        Long.parseLong(w.get("time").toString()) < dayTime + day).collect(Collectors.toList());
-                for (Map<String, Object> map : collect) {
-                    String abnormal_type = "";
-                    //过滤异常值
-                    if (map.get("abnormal_type") != null) {
-                        abnormal_type = map.get("abnormal_type").toString();
-                    }
-                    if (!abnormal_type.contains("tAve") || !abnormal_type.contains("t_ave")) {
-                        tsum = tsum.add(CalculationUtil.getBigDecimal(map.get("t_ave")));
-                    }
-                }
+                List<ProphaseWeatherData> collect = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= dayTime && p.getTs().getTime() < dayTime + day).collect(Collectors.toList());
+                //计算时间段内所有温度
+                BigDecimal tSum = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getTAve() != null && c.getTAve() != 0).mapToDouble(ProphaseWeatherData::getTAve).sum());
                 if (!collect.isEmpty()) {
                     WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                     windTowerCalculationData.setEbId(ebId);
                     windTowerCalculationData.setTime(new Date(dayTime));
-                    windTowerCalculationData.setValue(tsum.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP));
+                    windTowerCalculationData.setValue(tSum.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP));
                     windTowerCalculationData.setEquipmentId(equipmentId);
                     list.add(windTowerCalculationData);
                 }
@@ -1949,32 +1925,20 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param startTime              开始时间
      * @param endTime                结束时间
      * @param equipmentId            设备Id
-     * @param mapList                实时数据
      * @param equipmentAttributeList 属性集合
      */
-    public void paDay(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList) {
+    public void paDay(Date startTime, Date endTime, String equipmentId, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList) {
         String ebId = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("paDay")).collect(Collectors.toList()).get(0).getId();
         long day = 86400000L;
         ArrayList<WindTowerCalculationData> list = new ArrayList<>();
         removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebId);
         try {
             for (long time = startTime.getTime(); time < endTime.getTime(); time += day) {
-                BigDecimal paSum = BigDecimal.ZERO;
                 long dayTime = time;
                 //过滤一天数据
-                List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= dayTime &&
-                        Long.parseLong(w.get("time").toString()) < dayTime + day).collect(Collectors.toList());
-                for (Map<String, Object> map : collect) {
-                    String abnormal_type = "";
-                    //过滤异常值
-                    if (map.get("abnormal_type") != null) {
-                        abnormal_type = map.get("abnormal_type").toString();
-                    }
-                    if ((!abnormal_type.contains("tAve") || !abnormal_type.contains("t_ave")) && CalculationUtil.getBigDecimal(map.get("pa_ave")) != null) {
-                        paSum = paSum.add(CalculationUtil.getBigDecimal(map.get("pa_ave")));
-                    }
+                List<ProphaseWeatherData> collect = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= dayTime && p.getTs().getTime() < dayTime + day).collect(Collectors.toList());
+                BigDecimal paSum = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getPaAve() != null && c.getPaAve() != 0).mapToDouble(ProphaseWeatherData::getTAve).sum());
 
-                }
                 if (!collect.isEmpty()) {
                     WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                     windTowerCalculationData.setEbId(ebId);
@@ -1998,7 +1962,7 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * 计算上一个小时 每10分钟的风切变指数
      */
     @Transactional
-    public void calculateWindPowerShear(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<WindTowerCalculationData> windTowerCalculationDataList) {
+    public void calculateWindPowerShear(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<WindTowerCalculationData> windTowerCalculationDataList) {
         log.info("开始计算小时风切变指数");
         long startHour = startTime.getTime();
         long endHour = endTime.getTime();
@@ -2013,7 +1977,11 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                 heightMin = Integer.parseInt(getNumberFromString(h));
             }
         }
-        List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTime.getTime() && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+
+        //时间段内所有风数据
+//        List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTime.getTime() && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+        List<ProphaseAnemometryData> prophaseAnemometryData = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());
+
         List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getTime().after(startTime) &&
                 w.getTime().before(endTime) && w.getEquipmentId().equals(equipmentId)).collect(Collectors.toList());
         for (String h : heights) {
@@ -2030,7 +1998,7 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                 long start2 = start1 + 3600000L;
 
                 //查询指定时间的风速数据，如果是1号0点-1点执行则查询上一个月的数据  windTowerStatusDataList key=层高 + 毫秒数 + 设备编号 + 当前日的时间  value= 每个层高的平均风速
-                Map<String, BigDecimal> windTowerStatusDataList = queryWindForShear(new Date(start1), new Date(start2), equipmentId, collect);
+                Map<String, BigDecimal> windTowerStatusDataList = queryWindForShear(new Date(start1), new Date(start2), equipmentId, prophaseAnemometryData,heights);
                 //计算每10分钟的风切变指数          windTowerShearMap---> key=层高 + 设备编号  value = shear
                 Map<String, List<BigDecimal>> windTowerShearMap = traverseWindDataListCalcuShear(windTowerStatusDataList, heightMin);
                 //查询历史记录，以作更新操作        windTowerCalculationDataMap--->key= 时间 设备编号 EbId  value=windTowerCalculationData（所有数据）
@@ -2195,6 +2163,35 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
         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()) {
+                    //获取 毫秒数
+                    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点执行则查询上一个月的数据
@@ -2337,28 +2334,23 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param endTime     结束时间
      * @param equipmentId 设备id
      */
-    public void staMonth(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
+    public void staMonth(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
         //时间-1防止0点数据查不到
         Date startHour = new Date(startTime.getTime() - 1);
-        List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour.getTime() && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+        List<ProphaseAnemometryData> collect = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());
+
         List<WindTowerCalculationData> windTowerCalculationDataList = new ArrayList<>();
         String h = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights();
         String[] heights = h.split(",");
         //计算标差
         for (String height : heights) {
             List<EquipmentAttribute> equipmentAttributeList1 = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals(height + "staMonth")).collect(Collectors.toList());
-            List<BigDecimal> wsStaList = CalculationUtil.getWsStaForHeight(collect, height);
-            BigDecimal sumSta = new BigDecimal(0);
-            BigDecimal aveSta;
-            if (!wsStaList.isEmpty()) {
-                for (BigDecimal sta : wsStaList) {
-                    sumSta = sumSta.add(sta);
-                }
-                aveSta = sumSta.divide(new BigDecimal(wsStaList.size()), 2, RoundingMode.HALF_UP);
+            if (!collect.isEmpty()) {
+                BigDecimal sumSta = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getLayerHeight().equals(height)).mapToDouble(ProphaseAnemometryData::getWsSta).sum());
                 WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                 windTowerCalculationData.setEbId(equipmentAttributeList1.get(0).getId());
                 windTowerCalculationData.setTime(startHour);
-                windTowerCalculationData.setValue(aveSta);
+                windTowerCalculationData.setValue(sumSta.divide(new BigDecimal(collect.size()), 2, RoundingMode.HALF_UP));
                 windTowerCalculationData.setEquipmentId(equipmentId);
                 windTowerCalculationDataList.add(windTowerCalculationData);
             }
@@ -2378,14 +2370,14 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param startTime              开始时间
      * @param endTime                结束时间
      * @param equipmentId            设备id
-     * @param mapList                数据集合
      * @param equipmentAttributeList 属性集合
      */
-    public void environmentData(Date startTime, Date endTime, String equipmentId, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList) {
+    public void environmentData(Date startTime, Date endTime, String equipmentId, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList) {
         try {
             //时间-1防止0点数据查不到
             Date startHour = new Date(startTime.getTime() - 1);
-            List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour.getTime() && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+//            List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour.getTime() && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+            List<ProphaseWeatherData> prophaseWeatherData = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= startHour.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());
 
             equipmentAttributeList = equipmentAttributeList.stream().filter(w -> "environment".equals(w.getAttributeFunction())).collect(Collectors.toList());
             BigDecimal sumPa = new BigDecimal(0);
@@ -2394,25 +2386,21 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
             BigDecimal aveRh = new BigDecimal(0);
             BigDecimal sumT = new BigDecimal(0);
             BigDecimal aveT = new BigDecimal(0);
-            if (!collect.isEmpty()) {
+            if (!prophaseWeatherData.isEmpty()) {
                 List<BigDecimal> paList = new ArrayList<>();
                 List<BigDecimal> rhList = new ArrayList<>();
                 List<BigDecimal> tList = new ArrayList<>();
                 /*计算平均值数值为null 不计算*/
-                for (Map<String, Object> map : collect) {
+                for (ProphaseWeatherData map : prophaseWeatherData) {
                     String abnormal_type = "";
-                    //过滤异常值
-                    if (map.get("abnormal_type") != null) {
-                        abnormal_type = map.get("abnormal_type").toString();
+                    if (map.getPaAve() != null && map.getPaAve() != 0) {
+                        paList.add(CalculationUtil.getBigDecimal(map.getPaAve()));
                     }
-                    if (map.get("pa_ave") != null && !map.get("pa_ave").equals("")) {
-                        paList.add(CalculationUtil.getBigDecimal(map.get("pa_ave")));
+                    if (map.getRhAve() != null && map.getRhAve() != 0) {
+                        rhList.add(CalculationUtil.getBigDecimal(map.getRhAve()));
                     }
-                    if (map.get("rh_ave") != null && !map.get("rh_ave").equals("")) {
-                        rhList.add(CalculationUtil.getBigDecimal(map.get("rh_ave")));
-                    }
-                    if (map.get("t_ave") != null && !map.get("t_ave").equals("") && (!abnormal_type.contains("tAve") || !abnormal_type.contains("t_ave"))) {
-                        tList.add(CalculationUtil.getBigDecimal(map.get("t_ave")));
+                    if (map.getTAve() != null && map.getTAve() != 0) {
+                        tList.add(CalculationUtil.getBigDecimal(map.getTAve()));
                     }
                 }
                 /*气压*/
@@ -2538,11 +2526,10 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param equipmentId            设备Id
      * @param startTime              开始时间
      * @param endTime                结束时间
-     * @param mapList                实时数据
      * @param equipmentAttributeList 属性集合
      * @param windTowerInfoList      测风塔信息
      */
-    public void turbulenceHourForMonth(String equipmentId, Date startTime, Date endTime, List<Map<String, Object>> mapList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
+    public void turbulenceHourForMonth(String equipmentId, Date startTime, Date endTime, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
         String height = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights();
         String[] heights = height.split(",");
         long hour = 3600000L;
@@ -2562,18 +2549,18 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                     long startHour = time;
                     long endHour = time + hour;
                     //筛选小时数据
-                    List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour && Long.parseLong(w.get("time").toString()) <= endHour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
-                    //循环实时数据计算总风速和标差
-                    List<BigDecimal> wsForHeight = CalculationUtil.getWsForHeight(collect, h);
-                    List<BigDecimal> wsStaForHeight = CalculationUtil.getWsStaForHeight(collect, h);
+//                    List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour && Long.parseLong(w.get("time").toString()) <= endHour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+                    List<ProphaseAnemometryData> anemometryDataList = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startHour && p.getTs().getTime() <= endHour && p.getLayerHeight().equals(h)).collect(Collectors.toList());
 
-                    BigDecimal wsSun = wsForHeight.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
-                    BigDecimal staSun = wsStaForHeight.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
-                    if (collect.size() > 0) {
+
+                    if (anemometryDataList.size() > 0) {
                         BigDecimal turAve = BigDecimal.ZERO;
+                        //循环实时数据计算总风速和标差
+                        BigDecimal wsSun = CalculationUtil.getBigDecimal(anemometryDataList.stream().mapToDouble(ProphaseAnemometryData::getWsAve).sum());
+                        BigDecimal staSun = CalculationUtil.getBigDecimal(anemometryDataList.stream().mapToDouble(ProphaseAnemometryData::getWsSta).sum());
                         //除以一小时的个数 求小时的平均值
-                        BigDecimal wsAve = wsSun.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP);
-                        BigDecimal staAve = staSun.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP);
+                        BigDecimal wsAve = wsSun.divide(BigDecimal.valueOf(anemometryDataList.size()), 2, RoundingMode.HALF_UP);
+                        BigDecimal staAve = staSun.divide(BigDecimal.valueOf(anemometryDataList.size()), 2, RoundingMode.HALF_UP);
                         //如果除数等于0就跳过本次循环
                         if (wsAve.compareTo(BigDecimal.ZERO) == 0 || staAve.compareTo(BigDecimal.ZERO) == 0) {
                             continue;
@@ -2629,7 +2616,7 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
      * @param startTime   开始时间
      * @param endTime     结束时间
      */
-    public void airDensityMonth(String equipmentId, Date startTime, Date endTime, List<Map<String, Object>> mapList) {
+    public void airDensityMonth(String equipmentId, Date startTime, Date endTime, List<ProphaseWeatherData> prophaseWeatherDataList) {
         //获取ebId
         String ebId = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, "airDensityDayForYear").list().get(0).getId();
         removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, new Date(endTime.getTime() + 86400000L), equipmentId, ebId);
@@ -2643,16 +2630,16 @@ public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCa
                 BigDecimal airSun = BigDecimal.ZERO;
                 long startHour = time;
                 long endHour = time + hour;
-                List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour && Long.parseLong(w.get("time").toString()) <= endHour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
-
-                for (Map<String, Object> map : collect) {
+//                List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour && Long.parseLong(w.get("time").toString()) <= endHour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
+                List<ProphaseWeatherData> weatherDataList = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= startHour && p.getTs().getTime() <= endHour).collect(Collectors.toList());
+                for (ProphaseWeatherData map : weatherDataList) {
                     //过滤异常数据
-                    if (map.get("air_density") != null && !map.get("air_density").equals("")) {
-                        airSun = airSun.add(CalculationUtil.getBigDecimal(map.get("air_density")));
-                    }
+
+                    airSun = airSun.add(CalculationUtil.getBigDecimal(map.getAirDensity()));
+
                 }
-                if (collect.size() > 0) {
-                    BigDecimal airAve = airSun.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP);
+                if (weatherDataList.size() > 0) {
+                    BigDecimal airAve = airSun.divide(BigDecimal.valueOf(weatherDataList.size()), 2, RoundingMode.HALF_UP);
                     //判断map的key是否包含此小时  不包含直接加入value中 包含则相加
                     if (timeAndAirMap.get(new Date(startHour).getHours()) != null) {
 

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

@@ -1,6 +1,7 @@
 package com.jiayue.biz.util;
 
 import com.jiayue.biz.domain.ProphaseAnemometryData;
+import com.jiayue.biz.domain.ProphaseWeatherData;
 import com.jiayue.biz.domain.WindTowerCalculationData;
 import com.jiayue.biz.eunms.WindDirectionEnum;
 import javafx.scene.input.DataFormat;
@@ -30,7 +31,7 @@ public class CalculationUtil {
         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());
+            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());
         }
@@ -47,7 +48,7 @@ public class CalculationUtil {
         List<ProphaseAnemometryData> collect = new ArrayList<>();
         if (windEnum.name().equals("N")) {
             // N的范围为 348.75<wd<360 + 0<wd<11.25
-            List.stream().filter(w -> w.getWdAve() != null && (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());
+            List.stream().filter(w -> w.getWdAve() != null && (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());
         }
@@ -56,7 +57,7 @@ public class CalculationUtil {
 
 
     /**
-     * 根据层高获取风速数据
+     * 根据层高获取风速数据 todo 旧
      *
      * @param filterList 过滤出的风数据
      * @param fieldName  属性名（层高）
@@ -80,6 +81,7 @@ public class CalculationUtil {
         return wsList;
     }
 
+
     /**
      * 根据层高获取空气密度
      *
@@ -164,56 +166,53 @@ public class CalculationUtil {
 
 
     /**
-     * 计算风能密度(风功率玫瑰图)
+     * 计算风能密度(风功率玫瑰图) todo 旧
      *
-     * @param bigDecimalList 风速数据
-     * @param mapList        风数据
      * @return 风能密度
      */
-    public static BigDecimal windEnergyDensity(List<Map<String, Object>> mapList, List<BigDecimal> bigDecimalList, String height) {
+    public static BigDecimal windEnergyDensity(List<ProphaseAnemometryData> anemometryData, List<ProphaseWeatherData> weatherData) {
 
         BigDecimal density = new BigDecimal(-99);
         try {
-            // 过滤风速异常数据
-            List<Map<String, Object>> newList = new ArrayList<>();
-            for (Map<String, Object> map : mapList) {
-                String abnormal_type = "";
-                //过滤异常值
-                if (map.get("abnormal_type") != null) {
-                    abnormal_type = map.get("abnormal_type").toString();
-                }
-                if (map.get("ws_ave" + height) != null && !map.get("ws_ave" + height).equals("") && (!abnormal_type.contains("wsAve" + height) || !abnormal_type.contains("ws_ave" + height))) {
-                    newList.add(map);
-                }
-            }
-            if (bigDecimalList.size() == newList.size() && bigDecimalList.size() != 0) {
+            if (anemometryData.size() == weatherData.size() && anemometryData.size() != 0) {
                 BigDecimal count = new BigDecimal(0);
-                for (int i = 0; i < newList.size(); i++) {
-                    if (newList.get(i).get("air_density") != null && bigDecimalList.get(i) != null) {
-                        //计算风功率密度 空气密度*第i点的风速值的立方 求和/2 各个层高都有
-                        count = count.add(getBigDecimal(newList.get(i).get("air_density")).multiply(bigDecimalList.get(i).multiply(bigDecimalList.get(i)).multiply(bigDecimalList.get(i))));
+                for (int i = 0; i < anemometryData.size(); i++) {
+                    if (weatherData.get(i).getAirDensity() != null && anemometryData.get(i).getWsAve() != null) {
+                        if (weatherData.get(i).getTs().getTime() == anemometryData.get(i).getTs().getTime()) {
+                            //计算风功率密度 空气密度*第i点的风速值的立方 求和/2 各个层高都有
+                            count = count.add(wpdCalculate(getBigDecimal(weatherData.get(i).getAirDensity()),getBigDecimal(anemometryData.get(i).getWsAve())));
+                        } else {
+                            int finalI = i;
+                            List<ProphaseWeatherData> collect = weatherData.stream().filter(w -> w.getTs().getTime() == anemometryData.get(finalI).getTs().getTime()).collect(Collectors.toList());
+                            if (collect.size() > 0) {
+                                count = count.add(wpdCalculate(getBigDecimal(collect.get(0).getAirDensity()),getBigDecimal(anemometryData.get(i).getWsAve())));
+                            }
+                        }
                     }
                 }
-                density = count.divide((new BigDecimal(2).multiply(new BigDecimal(newList.size()))), 2, BigDecimal.ROUND_HALF_UP);
+                density = count.divide((new BigDecimal(weatherData.size())), 2, RoundingMode.HALF_UP);
             }
         } catch (Exception e) {
             log.error("计算风风能密度时发生错误");
         } finally {
             return density;
         }
+    }
 
+    //计算风功率密度公式
+    public static BigDecimal wpdCalculate(BigDecimal wsAve, BigDecimal airAve){
+       return airAve.multiply(power(getBigDecimal(wsAve), 3)).multiply(BigDecimal.valueOf(0.5));
     }
 
     /**
-     *
-     * @param x 参数
+     * @param x     参数
      * @param total 指数
      * @return x的total次方
      */
-    public static BigDecimal power(BigDecimal x,Integer total){
+    public static BigDecimal power(BigDecimal x, Integer total) {
         BigDecimal power = x;
         for (int i = 1; i < total; i++) {
-            power =  power.multiply(x);
+            power = power.multiply(x);
         }
         return power;
     }
@@ -369,10 +368,11 @@ public class CalculationUtil {
 
     /**
      * 机型：WH6.25N-182
+     *
      * @param ws 风速
      * @return 拟合功率 BigDecimal
      */
-    public static BigDecimal getBattery(BigDecimal ws){
+    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)