some

ruoyi-admin/src/main/java/com/ruoyi/web/controller/DebugController.java

@@ -0,0 +1,21 @@
+package com.ruoyi.web.controller;
+
+import com.alibaba.fastjson2.JSON;
+import com.ruoyi.ucp.util.CalcCache;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+@RestController
+@RequestMapping("/debug")
+public class DebugController {
+
+    @GetMapping("/get-dict-map")
+    public String getOneMap() {
+        return JSON.toJSONString(CalcCache.dictMap);
+    }
+    @GetMapping("/get-map-data")
+    public String getMapData(@RequestParam String name1, @RequestParam String name2) {
+        return JSON.toJSONString(CalcCache.dictMap.get(name1).getDouble(name2));
+    }
+}

ruoyi-admin/src/main/java/com/ruoyi/web/controller/Fq.java

@@ -885,4 +885,659 @@
 //    //powerLossesService.saveBatch(losses);
 //    ////powerLossesService.saveBatch(turbineLosses);
 //    //turbineInfoDayService.saveOrUpdateBatch(dayMap.values());
-//}
+//}
+
+
+/*
+public void calcTurbine5s_ha(DateTime begin, DateTime end, double ssxs) {
+    //风速
+    List<PointInfo> entityFs = getEntity("AI066", "turbine");
+    getSnapDataByEntity(entityFs, begin, end, 15);
+    Map<String, Map<String, List<PointData>>> fsMapMap = entityFs.stream().collect(Collectors.groupingBy(PointInfo::getStationId,
+            Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas)));
+    //功率
+    List<PointInfo> entityGl = getEntity("AI114", "turbine");
+    getSnapDataByEntity(entityGl, begin, end, 15);
+    Map<String, Map<String, List<PointData>>> glMapMap = entityGl.stream().collect(Collectors.groupingBy(PointInfo::getStationId,
+            Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas)));
+    //状态
+    List<PointInfo> ztMapMap = calcTurbineZt(begin, end, entityFs, entityGl);
+    Map<String, Map<String, PointInfo>> ztMapMapInfos = ztMapMap.stream().collect(
+            Collectors.groupingBy(PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, Function.identity())));
+
+    List<PointData> glpdss = entityFs.get(0).getPointDatas();
+    List<Double> zeroList = IntStream.range(0, glpdss.size()).mapToObj(i -> 0.0).collect(Collectors.toList());
+    Map<String, TurbineInfoDay> dayMap = getTurbineinfoMap(begin, entityFs);
+    ztMapMapInfos.forEach((stId, ztMapInfo) -> ztMapInfo.forEach((wtId, ztInfo) -> {
+        //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
+        // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
+        TurbineInfoDay infoDay = dayMap.get(wtId);
+        getXdQx(zeroList, ztInfo, fsMapMap.get(stId).get(wtId), glMapMap.get(stId).get(wtId));
+        Map<String, Double> loss = getTurbinePowerLoss(infoDay.getRfdl(), ztInfo, fsMapMap.get(stId).get(wtId), glMapMap.get(stId).get(wtId));
+        infoDay.setJhjxss(loss.get("jxss") * ssxs);
+        infoDay.setFjhjxss(loss.get("gzss") * ssxs + loss.get("fdjcl") * ssxs + loss.get("sdtj") * ssxs);
+        infoDay.setXdss(loss.get("xdjcl") * ssxs + loss.get("xdtj") * ssxs);
+        infoDay.setSlss(0.0);
+        infoDay.setDjss(loss.get("djss") * ssxs);
+        infoDay.setGzss(loss.get("gzss") * ssxs);
+        infoDay.setXnss(loss.get("xnss") * ssxs + loss.get("djss") * ssxs);
+        infoDay.setLlfdl(infoDay.getRfdl() + infoDay.getJhjxss() + infoDay.getFjhjxss() + infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
+    }));
+    List<Double> collect = zeroList.stream().map(v -> v / 240).collect(Collectors.toList());
+    List<Long> tss = glpdss.stream().map(v -> v.getTs()).collect(Collectors.toList());
+    List<PowerLosses> losses = calcLossPeriods(collect, tss);
+    QueryWrapper<PowerLosses> queryWrapper = new QueryWrapper<>();
+    queryWrapper.eq("record_date", new Date(begin.getTime()));
+    powerLossesService.remove(queryWrapper);
+    powerLossesService.saveBatch(losses);
+    turbineInfoDayService.saveOrUpdateBatch(dayMap.values());
+}*/
+/*
+public void acc(DateTime date) {
+    DateTime end = DateUtil.beginOfDay(date);
+    DateTime begin = DateUtil.offsetDay(end, -1);
+    List<TurbineInfoDay> byDate = getTurbineinfoByDate(begin);
+    byDate.forEach(tid -> {
+        tid.setLlfdl(tid.getRfdl() + tid.getXdss() + tid.getFjhjxss() + tid.getJhjxss() + tid.getXnss());
+    });
+    turbineInfoDayService.saveOrUpdateBatch(byDate);
+}*/
+/*public void calcTurbine5s2SameDay() {
+    DateTime time = DateUtil.date();
+    //date当天零点
+    DateTime time0 = DateUtil.beginOfDay(time);
+    //风速
+    List<PointInfo> entityFs = getEntity("AI066", "turbine");
+    //功率
+    List<PointInfo> entityGl = getEntity("AI114", "turbine");
+    //状态
+    List<PointInfo> entityZT = getEntity("MXZT", "turbine");
+    Map<String, Map<String, PointInfo>> ztMapMapInfos = entityZT.stream().collect(Collectors.groupingBy(PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, Function.identity())));
+    Map<String, TurbineInfoDay> dayMap = getTurbineinfoMap(time0, entityFs);
+    List<TurbineInfoDay> infoDays = new ArrayList<>();
+    Map<String, Map<String, PointInfo>> fsMapMap = entityFs.stream().collect(Collectors.groupingBy(PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, Function.identity())));
+    Map<String, Map<String, PointInfo>> glMapMap = entityGl.stream().collect(Collectors.groupingBy(PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, Function.identity())));
+
+    ztMapMapInfos.forEach((stId, ztMapInfo) -> ztMapInfo.forEach((wtId, ztInfo) -> {
+        //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
+        // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
+        TurbineInfoDay infoDay = dayMap.get(wtId);
+        PointInfo fspi = fsMapMap.get(stId).get(wtId);
+        PointInfo glpi = glMapMap.get(stId).get(wtId);
+        getSnapDataByEntity(fspi, time0, time, 15);
+        getSnapDataByEntity(glpi, time0, time, 15);
+        getSnapDataByEntity(ztInfo, taosUri(), time0, time, 15);
+        List<PointData> fsData = fspi.getPointDatas();
+        fsData = fsData.stream().peek(pd -> pd.setDoubleValue(NumberUtil.round(pd.getValue() > 25 ? 25.0 : pd.getValue(), 2).doubleValue())).collect(Collectors.toList());
+        Map<String, Double> loss = getTurbinePowerLoss(infoDay.getRfdl(), ztInfo, fsData, glpi.getPointDatas());
+        infoDay.setJhjxss(loss.get("jxss") + loss.get("sdtj"));
+        infoDay.setFjhjxss(loss.get("gzss") + loss.get("fdjcl"));
+        infoDay.setXdss(loss.get("xdjcl") + loss.get("xdtj"));
+        infoDay.setSlss(0.0);
+        infoDay.setDjss(loss.get("djss"));
+        infoDay.setGzss(loss.get("gzss"));
+        infoDay.setXnss(loss.get("xnss") + loss.get("djss"));
+        //if (infoDay.getRfdl() == 0) {
+        //    infoDay.setXnss(0.0);
+        //} else {
+        //    infoDay.setXnss(loss.get("xnss"));
+        //}
+        infoDay.setLlfdl(infoDay.getRfdl() + infoDay.getJhjxss() + infoDay.getFjhjxss() + infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
+        infoDays.add(infoDay);
+    }));
+    turbineInfoDayService.saveOrUpdateBatch(infoDays);
+}*/
+    /*public void calcTurbine5s(Date date) {
+        //date当天零点
+        DateTime time = DateUtil.beginOfDay(date);
+        //date昨天零点
+        DateTime time0 = DateUtil.offsetDay(time, -1);
+
+        //状态
+        List<PointInfo> entityZt = getEntity("MXZT", "turbine");
+        //功率
+        Map<String, String> collectGl = getEntityMap("AI114", "turbine");
+        //风速
+        Map<String, String> collectFs = getEntityMap("AI066", "turbine");
+
+        Map<String, TurbineInfoDay> dayMap = getTurbineinfoMap(time0, entityZt);
+
+        String tbId;
+        TurbineInfoDay infoDay;
+        List<TurbineInfoDay> infoDays = new ArrayList<>();
+        for (PointInfo info : entityZt) {
+            tbId = info.getTurbineId();
+            List<PointData> snapZt = adapter.getHistorySnap(taosUri(), info.getPointKey(), time0.getTime(), time.getTime(), 60);
+            //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
+            // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
+
+            List<DoubleStatData> statGl = adapter.getHistoryStat2(goldenUri(), collectGl.get(tbId), time0.getTime(), time.getTime(), 60);
+            List<DoubleStatData> statFs = adapter.getHistoryStat2(goldenUri(), collectFs.get(tbId), time0.getTime(), time.getTime(), 60);
+            List<PointData> glList = statGl.stream().map(DoubleStatData::getAvg).collect(Collectors.toList());
+            List<PointData> fsList = statFs.stream().map(DoubleStatData::getAvg)
+                    .peek(fs -> {
+                        if (fs.getValue() < 25) {
+                            fs.setDoubleValue(NumberUtil.round(fs.getValue(), 2).doubleValue());
+                        } else {
+                            fs.setDoubleValue(25.0);
+                        }
+                    }).collect(Collectors.toList());
+
+//            Map<String, Double> loss = getTurbinePowerLoss(snapZt, fsList, tbId, glList);
+            Map<String, Double> loss = new HashMap<>();
+
+            infoDay = dayMap.get(tbId);
+            infoDay.setJhjxss(loss.get("jxss") + loss.get("sdtj"));
+            infoDay.setFjhjxss(loss.get("gzss") + loss.get("djss") + loss.get("fdjcl"));
+            infoDay.setXdss(loss.get("xdjcl") + loss.get("xdtj"));
+            infoDay.setSlss(0.0);
+            if (infoDay.getRfdl() == 0) {
+                infoDay.setXnss(0.0);
+            } else {
+                infoDay.setXnss(loss.get("xnss") * 0.1);
+            }
+            infoDay.setLlfdl(infoDay.getRfdl() + infoDay.getJhjxss() + infoDay.getFjhjxss() +
+                    infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
+            infoDays.add(infoDay);
+        }
+        turbineInfoDayService.saveOrUpdateBatch(infoDays);
+    }*/
+/*
+public void calcTurbine5s2(Date date) {
+    //date当天零点
+    DateTime time = DateUtil.beginOfDay(date);
+    //date昨天零点
+    DateTime time0 = DateUtil.offsetDay(time, -1);
+    //风速
+    List<PointInfo> entityFs = getEntity("AI066", "turbine");
+    //功率
+    List<PointInfo> entityGl = getEntity("AI114", "turbine");
+    getSnapDataByEntity(entityFs, time0, time, 15);
+    getSnapDataByEntity(entityGl, time0, time, 15);
+
+    List<PointInfo> ztMapMap = calcTurbineZt(time0, time, entityFs, entityGl);
+    Map<String, Map<String, PointInfo>> ztMapMapInfos = ztMapMap.stream().collect(
+            Collectors.groupingBy(PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, Function.identity())));
+    Map<String, TurbineInfoDay> dayMap = getTurbineinfoMap(time0, entityFs);
+
+    List<TurbineInfoDay> infoDays = new ArrayList<>();
+    Map<String, Map<String, List<PointData>>> fsMapMap = entityFs.stream().collect(Collectors.groupingBy(PointInfo::getStationId,
+            Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas)));
+    Map<String, Map<String, List<PointData>>> glMapMap = entityGl.stream().collect(Collectors.groupingBy(PointInfo::getStationId,
+            Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas)));
+
+    ztMapMapInfos.forEach((stId, ztMapInfo) -> ztMapInfo.forEach((wtId, ztInfo) -> {
+        //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
+        // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
+        TurbineInfoDay infoDay = dayMap.get(wtId);
+        Map<String, Double> loss = getTurbinePowerLoss(infoDay.getRfdl(), ztMapMapInfos.get(stId).get(wtId), fsMapMap.get(stId).get(wtId), glMapMap.get(stId).get(wtId));
+        infoDay.setJhjxss(loss.get("jxss") + loss.get("sdtj"));
+        infoDay.setFjhjxss(loss.get("gzss") + loss.get("fdjcl"));
+        infoDay.setXdss(loss.get("xdjcl") + loss.get("xdtj"));
+        infoDay.setSlss(0.0);
+        infoDay.setDjss(loss.get("djss"));
+        infoDay.setGzss(loss.get("gzss"));
+        infoDay.setXnss(loss.get("xnss") + loss.get("djss"));
+        //if (infoDay.getRfdl() == 0) {
+        //    infoDay.setXnss(0.0);
+        //} else {
+        //    infoDay.setXnss(loss.get("xnss"));
+        //}
+        infoDay.setLlfdl(infoDay.getRfdl() + infoDay.getJhjxss() + infoDay.getFjhjxss() +
+                infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
+        infoDays.add(infoDay);
+    }));
+    turbineInfoDayService.saveOrUpdateBatch(infoDays);
+}*/
+/*
+public void calcTurbine5sSameDay(DateTime begin, DateTime end) {
+    //风速
+    List<PointInfo> entityFs = getEntity("AI066", "turbine");
+    getSnapDataByEntity(entityFs, begin, end, 15);
+    Map<String, Map<String, List<PointData>>> fsMapMap = entityFs.stream().collect(Collectors.groupingBy
+            (PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas)));
+    //功率
+    List<PointInfo> entityGl = getEntity("AI114", "turbine");
+    getSnapDataByEntity(entityGl, begin, end, 15);
+    Map<String, Map<String, List<PointData>>> glMapMap = entityGl.stream().collect(Collectors.groupingBy
+            (PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas)));
+    //状态
+    List<PointInfo> ztMapMap = calcTurbineZt(begin, end, entityFs, entityGl);
+    Map<String, Map<String, PointInfo>> ztMapMapInfos = ztMapMap.stream().collect(Collectors.groupingBy
+            (PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, Function.identity())));
+    //AGC
+    List<PointInfo> entityAgc = getEntity("AGC002", "booster");
+    getSnapDataByEntity(entityAgc, begin, end, 15);
+    //出线
+    List<PointInfo> entityCx = getEntity("AGC020", "booster");
+    getSnapDataByEntity(entityCx, begin, end, 15);
+    //可用功率
+    List<PointData> kyglpds = adapter.getHistorySnap(goldenUri(), "区域集控.惠安风场.升压站.中车风机设备信息.可用发电功率", begin.getTime(), end.getTime(), 15);
+    List<PointData> kyglpds2 = adapter.getHistorySnap(goldenUri(), "区域集控.惠安风场.升压站.联合动力能管信息.可用发电功率", begin.getTime(), end.getTime(), 15);
+    CollUtil.forEach(kyglpds, (pd, i) -> pd.setDoubleValue(pd.getValue() + kyglpds2.get(i).getValue()));
+    //信息表
+    Map<String, TurbineInfoMin> dayMap = getTurbineinfoByMinMap(begin, entityFs);
+    List<TurbineInfoMin> infoDays = new ArrayList<>();
+    ztMapMapInfos.forEach((stId, ztMapInfo) -> ztMapInfo.forEach((wtId, ztInfo) -> {
+        //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
+        // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
+        TurbineInfoMin infoDay = dayMap.get(wtId);
+        Map<String, Double> loss = getTurbinePowerLoss(ztMapMapInfos.get(stId).get(wtId), fsMapMap.get(stId).get(wtId), glMapMap.get(stId).get(wtId));
+        infoDay.setJhjxss(loss.get("jxss") + loss.get("sdtj"));
+        infoDay.setFjhjxss(loss.get("gzss") + loss.get("fdjcl"));
+        infoDay.setXdss(loss.get("xdjcl") + loss.get("xdtj"));
+        infoDay.setSlss(0.0);
+        infoDay.setDjss(loss.get("djss"));
+        infoDay.setGzss(loss.get("gzss"));
+        infoDay.setXnss(loss.get("xnss") + loss.get("djss"));
+        infoDay.setLlfdl(infoDay.getJhjxss() + infoDay.getFjhjxss() +
+                infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
+        infoDays.add(infoDay);
+    }));
+    turbineInfoMinService.saveOrUpdateBatch(infoDays);
+}*/
+/*
+public void calcTurbine5s2_ha(Date date) {
+    //date当天零点
+    DateTime time = DateUtil.beginOfDay(date);
+    //date昨天零点
+    DateTime time0 = DateUtil.offsetDay(time, -1);
+    //风速
+    List<PointInfo> entityFs = getEntity("AI066", "turbine");
+    //功率
+    List<PointInfo> entityGl = getEntity("AI114", "turbine");
+    getSnapDataByEntity(entityFs, time0, time, 15);
+    getSnapDataByEntity(entityGl, time0, time, 15);
+
+    List<PointData> glpdss = entityGl.get(0).getPointDatas();
+    TimeSeriesChart example = new TimeSeriesChart("分析限电");
+    List<Double> zeroList = IntStream.range(0, glpdss.size()).mapToObj(i -> 0.0).collect(Collectors.toList());
+
+    List<PointInfo> ztMapMap = calcTurbineZtC(example, time0, time, entityFs, entityGl);
+    //List<PointInfo> ztMapMap = calcTurbineZt(time0, time, entityFs, entityGl);
+    Map<String, Map<String, PointInfo>> ztMapMapInfos = ztMapMap.stream().collect(
+            Collectors.groupingBy(PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, Function.identity())));
+    Map<String, TurbineInfoDay> dayMap = getTurbineinfoMap(time0, entityFs);
+
+    List<TurbineInfoDay> infoDays = new ArrayList<>();
+    Map<String, Map<String, List<PointData>>> fsMapMap = entityFs.stream().collect(Collectors.groupingBy(PointInfo::getStationId,
+            Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas)));
+    Map<String, Map<String, List<PointData>>> glMapMap = entityGl.stream().collect(Collectors.groupingBy(PointInfo::getStationId,
+            Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas)));
+
+    ztMapMapInfos.forEach((stId, ztMapInfo) -> ztMapInfo.forEach((wtId, ztInfo) -> {
+        //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
+        // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
+        TurbineInfoDay infoDay = dayMap.get(wtId);
+        //getXdQx(zeroList, ztMapMapInfos.get(stId).get(wtId), fsMapMap.get(stId).get(wtId), glMapMap.get(stId).get(wtId));
+        Map<String, Double> loss = getTurbinePowerLoss(infoDay.getRfdl(), ztMapMapInfos.get(stId).get(wtId), fsMapMap.get(stId).get(wtId), glMapMap.get(stId).get(wtId));
+        infoDay.setJhjxss(loss.get("jxss") / 10 + loss.get("sdtj") / 10);
+        infoDay.setFjhjxss(loss.get("gzss") / 10 + loss.get("fdjcl") / 10);
+        infoDay.setXdss(loss.get("xdjcl") / 10 + loss.get("xdtj") / 10);
+        infoDay.setSlss(0.0);
+        infoDay.setDjss(loss.get("djss") / 10);
+        infoDay.setGzss(loss.get("gzss") / 10);
+        infoDay.setXnss(loss.get("xnss") / 10 + loss.get("djss") / 10);
+        //if (infoDay.getRfdl() == 0) {
+        //    infoDay.setXnss(0.0);
+        //} else {
+        //    infoDay.setXnss(loss.get("xnss"));
+        //}
+        infoDay.setLlfdl(infoDay.getRfdl() + infoDay.getJhjxss() + infoDay.getFjhjxss() +
+                infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
+        infoDays.add(infoDay);
+    }));
+
+    XYSeries seriesXdl = new XYSeries("限电电量");
+    for (int i = 0; i < glpdss.size(); i++) {
+        long ts = glpdss.get(i).getTs();
+        //seriesXdl.add(calcTime(ts),zeroList.get(i)*1000/2400);
+        System.out.println(DateUtil.formatDateTime(new Date(ts)) + "," + zeroList.get(i) * 1000 / 2400);
+    }
+    example.add(seriesXdl);
+    example.create();
+
+    turbineInfoDayService.saveOrUpdateBatch(infoDays);
+}*/
+/*
+public void calcTurbine5s(DateTime begin, DateTime end, double ssxs, List<PointData> kygl) {
+    //风速
+    List<PointInfo> entityFs = getEntity("AI066", "turbine");
+    getSnapDataByEntity(entityFs, begin, end, 15);
+    Map<String, List<PointData>> fsMap = entityFs.stream().collect(Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas));
+    //功率
+    List<PointInfo> entityGl = getEntity("AI114", "turbine");
+    getSnapDataByEntity(entityGl, begin, end, 15);
+    Map<String, List<PointData>> glMap = entityGl.stream().collect(Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas));
+    //状态
+    List<PointInfo> ztMapMap = calcTurbineZt(begin, end, entityFs, entityGl);
+    Map<String, Map<String, PointInfo>> ztMapMapInfos = ztMapMap.stream().collect(
+            Collectors.groupingBy(PointInfo::getStationId, Collectors.toMap(PointInfo::getTurbineId, Function.identity())));
+    //发电量
+    List<PointInfo> fdlEntity = getEntity("AI121", "turbine");
+    getSnapDataByEntity(fdlEntity, begin, end, 15);
+    Map<String, PointInfo> fdlMap = fdlEntity.stream().collect(Collectors.toMap(PointInfo::getTurbineId, Function.identity()));
+
+    List<PointData> glpdss = entityGl.get(0).getPointDatas();
+    List<Long> tss = glpdss.stream().map(v -> v.getTs()).collect(Collectors.toList());
+    List<Double> zeroList = IntStream.range(0, glpdss.size()).mapToObj(i -> 0.0).collect(Collectors.toList());
+    List<PointData> tbFsPdList = new ArrayList<>();
+    List<PowerLosses> turbineLosses = new ArrayList<>();
+    Map<String, TurbineInfoDay> dayMap = getTurbineinfoMap(begin, entityFs);
+    ztMapMapInfos.forEach((stId, ztMapInfo) -> ztMapInfo.forEach((wtId, ztInfo) -> {
+        //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
+        // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
+        List<PointData> fsPds = fsMap.get(wtId);
+        TurbineInfoDay infoDay = dayMap.get(wtId);
+        List<Double> turbineZeroList = IntStream.range(0, glpdss.size()).mapToObj(i -> 0.0).collect(Collectors.toList());
+        getXdQx(turbineZeroList, zeroList, ztInfo, fsPds, glMap.get(wtId));
+        Map<String, Double> loss = getTurbinePowerLoss(infoDay.getRfdl(), ztInfo, fsPds, glMap.get(wtId));
+        infoDay.setJhjxss(loss.get("jxss") * ssxs);
+        infoDay.setFjhjxss(loss.get("gzss") * ssxs + loss.get("fdjcl") * ssxs + loss.get("sdtj") * ssxs);
+        infoDay.setXdss(loss.get("xdjcl") * ssxs + loss.get("xdtj") * ssxs);
+        infoDay.setSlss(0.0);
+        infoDay.setDjss(loss.get("djss") * ssxs);
+        infoDay.setGzss(loss.get("gzss") * ssxs);
+        infoDay.setXnss(loss.get("xnss") * ssxs + loss.get("djss") * ssxs);
+        infoDay.setLlfdl(infoDay.getRfdl() + infoDay.getJhjxss() + infoDay.getFjhjxss() + infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
+        //风机限电时段
+        List<Double> collect = turbineZeroList.stream().map(v -> v / 240).collect(Collectors.toList());
+        List<PowerLosses> tblss = calcLossPeriods(collect, tss);
+        PointInfo fdlPis = fdlMap.get(wtId);
+        List<PointData> fdlPds = fdlPis.getPointDatas();
+        for (PowerLosses pl : tblss) {
+            pl.setItem("turbine");
+            pl.setStationId(stId);
+            pl.setTurbineId(wtId);
+            List<PointData> tbXdPdsn = fdlPds.stream().filter(pd -> isTimeIn(pd.getTs(), pl)).collect(Collectors.toList());
+            List<PointData> tbFsPdsn = fsPds.stream().filter(pd -> isTimeIn(pd.getTs(), pl)).collect(Collectors.toList());
+            pl.setFdl(calcHaDl(tbXdPdsn, fdlPis.getCoef()));
+            double pjfs = tbFsPdsn.stream().mapToDouble(pd -> pd.getValue()).average().orElse(0d);
+            pl.setPjfs(pjfs);
+            tbFsPdList.addAll(tbFsPdsn);
+        }
+        turbineLosses.addAll(tblss);
+    }));
+    //场站限电时段
+    List<Double> collect = zeroList.stream().map(v -> v / 240).collect(Collectors.toList());
+    List<PowerLosses> losses = calcLossPeriods(collect, tss);
+    for (PowerLosses loss : losses) {
+        loss.setItem("station");
+        double pjfs = tbFsPdList.stream().filter(pd -> isTimeIn(pd.getTs(), loss)).mapToDouble(pd -> pd.getValue()).average().orElse(0d);
+        loss.setPjfs(pjfs);
+        double fdl = turbineLosses.stream().filter(tl -> isTimeIn(tl, loss)).mapToDouble(PowerLosses::getFdl).sum();
+        loss.setFdl(fdl);
+    }
+    QueryWrapper<PowerLosses> queryWrapper = new QueryWrapper<>();
+    queryWrapper.eq("record_date", new Date(begin.getTime()));
+    powerLossesService.remove(queryWrapper);
+    powerLossesService.saveBatch(losses);
+    //powerLossesService.saveBatch(turbineLosses);
+    turbineInfoDayService.saveOrUpdateBatch(dayMap.values());
+}*/
+
+
+//依赖calcTurbineRfdl、calcTurbineStateMin、calcTurbine5s2
+/*
+
+public void calcTurbineLyxs(Date date) {
+    //date当天零点
+    DateTime time = DateUtil.beginOfDay(date);
+    //date昨天零点
+    DateTime time0 = DateUtil.offsetDay(time, -1);
+    List<TurbineInfoDay> byDate = getTurbineinfoByDate(time0);
+    Map<String, PointInfo> entityAiZt = getEntity("AI422", "state", PointInfo::getTurbineId);
+
+    for (TurbineInfoDay day : byDate) {
+        String tbId = day.getTurbineId();
+        double lyxs = day.getRfdl() / entityAiZt.get(tbId).getSpare2();
+        //double klyl = (24 * 60 - day.getGzMin() - day.getTjMin() - day.getJxMin()) / (24 * 60);
+        double klyl = (24 * 60 - day.getGzMin() - day.getJxMin()) / (24 * 60);
+        double fnlyl = divInfinite(day.getRfdl(), day.getLlfdl());
+        day.setLyxs(lyxs);
+        day.setKlyl(klyl * 100);
+        day.setFnlyl(fnlyl * 100);
+    }
+    turbineInfoDayService.saveOrUpdateBatch(byDate);
+}*/
+////场站限电五损
+//public void calcStation5s(DateTime begin, DateTime end) {
+//    if (end.equals(DateUtil.beginOfDay(end))) return;
+//    //AGC
+//    List<PointInfo> entityAgc = CalcCache.pointInfosMap.get("推送-booster-AGC-snap15s");
+//    //出线
+//    List<PointInfo> entityCx = CalcCache.pointInfosMap.get("推送-booster-出线-snap15s");
+//    //可用功率
+//    List<PointData> kyglpds = CalcCache.pointDatasMap.get("推送-booster-可用功率-snap15s");
+//    PointInfo cxPi = entityCx.get(0);
+//    List<PointData> cxPds = cxPi.getPointDatas();
+//    List<PointData> czxd = calcStationXd2(entityAgc.get(0), cxPds, kyglpds, 0.01);
+//    List<Double> xdl = new ArrayList<>();
+//
+//    for (int i = 0; i < cxPds.size(); i++) {
+//        double v = kyglpds.get(i).getValue() * 1000 - cxPds.get(i).getValue() * cxPi.getCoef();
+//        if (v < 0) v = 0;
+//        if (czxd.get(i).isBooleanValue()) {
+//            xdl.add(v);
+//        } else {
+//            xdl.add(0d);
+//        }
+//    }
+//    double sumxdl = xdl.stream().mapToDouble(Double::doubleValue).sum() / 2400000;
+//    //adapter.writeHistoryBatch(mqttUri(), getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl, 1));
+//
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", sumxdl/tsAdd(sumxdl, "日发电量")*100);
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", tsDiv("月限电量",tsAdd("月限电量", "月发电量"))*100);
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", tsDiv("年限电量",tsAdd("年限电量", "年发电量"))*100);
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.日限电率").getValue());
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.月限电率").getValue());
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.年限电率").getValue());
+//}
+
+//废弃
+//public void calcStation5s(DateTime begin, DateTime end) {
+//    if (end.equals(DateUtil.beginOfDay(end))) return;
+//    //AGC
+//    List<PointInfo> entityAgc = CalcCache.pointInfosMap.get("推送-booster-AGC-snap15s");
+//    //出线
+//    List<PointInfo> entityCx = CalcCache.pointInfosMap.get("推送-booster-出线-snap15s");
+//    //可用功率
+//    List<PointData> kyglpds = CalcCache.pointDatasMap.get("推送-booster-可用功率-snap15s");
+//    PointInfo cxPi = entityCx.get(0);
+//    List<PointData> cxPds = cxPi.getPointDatas();
+//    List<PointData> czxd = calcStationXd2(entityAgc.get(0), cxPds, kyglpds, 0.01);
+//    List<Double> xdl = new ArrayList<>();
+//
+//    for (int i = 0; i < cxPds.size(); i++) {
+//        double v = kyglpds.get(i).getValue() * 1000 - cxPds.get(i).getValue() * cxPi.getCoef();
+//        if (v < 0) v = 0;
+//        if (czxd.get(i).isBooleanValue()) {
+//            xdl.add(v);
+//        } else {
+//            xdl.add(0d);
+//        }
+//    }
+//    double sumxdl = xdl.stream().mapToDouble(Double::doubleValue).sum() / 2400000;
+//    //adapter.writeHistoryBatch(mqttUri(), getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl, 1));
+//    getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl, 1);
+//
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", sumxdl / tsAdd(sumxdl, "日发电量") * 100);
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", tsDiv("月限电量", tsAdd("月限电量", "月发电量")) * 100);
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", tsDiv("年限电量", tsAdd("年限电量", "年发电量")) * 100);
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.日限电率").getValue());
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.月限电率").getValue());
+//    getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.年限电率").getValue());
+//}
+
+    /*public void calcPowerConsistencyCoefficient(DateTime begin, DateTime end) {
+        final String model1 = "WT2000D121H85";
+        final String model2 = "UP2000-130";
+        final String project1 = "NX_FGS_HAF01_EG";
+        final String project2 = "NX_FGS_HAF02_EG";
+
+        QueryWrapper<TurbineInfoMin> qw = new QueryWrapper<>();
+        qw.between("record_date", begin, end);
+        List<TurbineInfoMin> turMins = turbineInfoMinService.list(qw);
+        Map<String, List<TurbineInfoMin>> wtMap = turMins.stream().collect(Collectors.groupingBy(TurbineInfoMin::getTurbineId));
+
+        //获取 保证功率
+        List<ProBasicModelPowerRd> modelPowerRds = proBasicModelPowerRdService.list();
+        //保证功率 按照机型分组
+        Map<String, List<ProBasicModelPowerRd>> modelMap = modelPowerRds.stream().collect(Collectors.groupingBy(ProBasicModelPowerRd::getModelId));
+
+        //保证功率 建立风速Map 对应表
+        Map<String, Map<Double, ProBasicModelPowerRd>> modelSpeedMap = new HashMap<>();
+        modelMap.forEach((key, value) -> {
+            Map<Double, ProBasicModelPowerRd> mod = value.stream().collect(Collectors.toMap(ProBasicModelPowerRd::getSpeed, Function.identity()));
+            if (model1.equals(key)) {
+                modelSpeedMap.put("WT2000D121H85", mod);
+            } else if (model2.equals(key)) {
+                modelSpeedMap.put("UP2000-130", mod);
+            }
+        });
+
+        Map<Double, ProBasicModelPowerRd> bzglMap = new HashMap<>();
+
+        //风机编号，风速，功率
+        Map<String, Double> glyzxxsMap = new HashMap<>();
+        for (Map.Entry<String, List<TurbineInfoMin>> entry : wtMap.entrySet()) {
+            String key = entry.getKey();
+            List<TurbineInfoMin> value = entry.getValue();
+            List<Double> ls = new ArrayList<>();
+            //单台风机 根据风速分组-风机表
+            Map<Double, List<TurbineInfoMin>> fsMap = value.stream().collect(Collectors.groupingBy(fs -> NumberUtil.round(fs.getPjfs(), 2).doubleValue()));
+
+            //根据风速将 功率求平均值
+            for (Map.Entry<Double, List<TurbineInfoMin>> ent : fsMap.entrySet()) {
+                Double k = ent.getKey();
+                List<TurbineInfoMin> val = ent.getValue();
+                double gl = 0.0;
+                if (val.size() > 1) {
+                    DoubleSummaryStatistics glAvg = val.stream().mapToDouble(TurbineInfoMin::getPjgl).summaryStatistics();
+                    gl = glAvg.getAverage();
+                } else {
+                    gl = val.get(0).getPjgl();
+                }
+
+                //计算 功率一致性系数
+                double glyzxxs = 0.0;
+                if (gl != 0) {
+                    if (project1.equals(val.get(0).getProjectId())) {
+                        bzglMap = modelSpeedMap.get(model1);
+                    } else if (project2.equals(val.get(0).getProjectId())) {
+                        bzglMap = modelSpeedMap.get(model2);
+                    }
+                    if (bzglMap.containsKey(k)) {
+                        double bzgl = bzglMap.get(k).getEnsurePower();
+                        if (bzgl != 0) {
+                            glyzxxs = (gl / bzgl) * 100;
+                            if (glyzxxs > 80 && glyzxxs < 120) {
+                                ls.add(glyzxxs);
+                            }
+                        }
+                    }
+                }
+
+            }
+            ls.stream().mapToDouble(Double::doubleValue).average().ifPresent(avg -> glyzxxsMap.put(key, avg));
+        }
+
+        //获取当天风机表
+        List<TurbineInfoDay> byDate = getTurbineinfoByDate(begin);
+        for (TurbineInfoDay info : byDate) {
+            if (glyzxxsMap.containsKey(info.getTurbineId())) {
+                double glyzxxs = glyzxxsMap.get(info.getTurbineId());
+                if (glyzxxs > 100) {
+                    glyzxxs = 100;
+                } else if (glyzxxs < 90) {
+                    glyzxxs = 90;
+                }
+                info.setGlyzxxs(NumberUtil.round(glyzxxs, 2).doubleValue());
+            }
+        }
+        turbineInfoDayService.saveOrUpdateBatch(byDate);
+    }*/
+
+
+//废弃
+/*public void calcStationYcglSwdl(Date time) {
+    DateTime beginOfDay = DateUtil.beginOfDay(time);
+    //时间调为整15分钟
+    DateTime time0 = DateUtil.beginOfMinute(time);
+    int i = Math.floorDiv(time0.minute(), 15) * 15;
+    time0.setMinutes(i);
+    //短期
+    long l = DateUtil.between(beginOfDay, time0, DateUnit.MINUTE) / 15 + 48;
+    String dq = "区域集控.惠安风场.WpdToDip.短期1.短期" + l;
+    //FCFGDQDT0015-96-区域集控.惠安风场.WpdToDip.短期1.短期
+    //FCFGCDQ0001-16-区域集控.惠安风场.WpdToDip.超短期.超短期
+    //FCFGLLCDQ0001-24-区域集控.惠安风场.WpdToDip.理论超短期.理论超短期
+    //String tagNames = "区域集控.惠安风场.上网电量,区域集控.惠安风场.短期功率预测,区域集控.惠安风场.超短期功率预测,区域集控.惠安风场.理论超短期功率预测,区域集控.惠安风场.风速,区域集控.惠安风场.并网总有功功率";
+    //String tagNames = "区域集控.惠安风场.上网电量,区域集控.惠安风场.短期功率预测,区域集控.惠安风场.超短期功率预测";
+    DateTime begin = DateUtil.offsetMinute(time0, -15);
+    long dqTime = beginOfDay.getTime();
+    if ((time0.getHours() == 12 && time0.getMinutes() >= 15) || time0.getHours() > 12) dqTime = time.getTime();
+    Map<String, PointData> dqData = adapter.getHistorySection(goldenUri(), dq, dqTime);
+    //出线
+    List<PointInfo> entityCx = getEntity("AGC001", "booster");
+    Map<String, PointInfo> cxData = getRawDataByEntity(entityCx, goldenUri(), begin, time0, PointInfo::getStationId);
+    //超短期
+    DateTime cdqTime = DateUtil.offsetMinute(time0, -115);
+    String cdq = "区域集控.惠安风场.WpdToDip.超短期.超短期8";
+    Map<String, PointData> cdqData = adapter.getHistorySection(goldenUri(), cdq, cdqTime.getTime());
+    //理论超短期
+    String llcdq = "区域集控.惠安风场.WpdToDip.理论超短期.理论超短期8";
+    Map<String, PointData> llcdqData = adapter.getHistorySection(goldenUri(), llcdq, cdqTime.getTime());
+
+    List<StationInfoMin> byDate = getStationinfoByMin(begin, entityCx);
+    for (StationInfoMin day : byDate) {
+        PointInfo cxInfo = cxData.get(day.getStationId());
+        double pjgl = 0, dqycgl = 0, cdqycgl = 0, llcdqycgl = 0;
+        if (cxInfo != null) {
+            pjgl = cxInfo.getPointDatas().stream().mapToDouble(PointData::getValue).average().orElse(0) * cxInfo.getCoef();
+        }
+        day.setPjgl(pjgl);
+        if (!dqData.isEmpty()) {
+            dqycgl = dqData.values().stream().findFirst().get().getValue();
+        }
+        if (!cdqData.isEmpty()) {
+            cdqycgl = cdqData.values().stream().findFirst().get().getValue();
+        }
+        if (!llcdqData.isEmpty()) {
+            llcdqycgl = llcdqData.values().stream().findFirst().get().getValue();
+        }
+        double pjglw = pjgl / 1000;
+        if (pjglw < 0) pjglw = 0;
+        day.setDqycgl(dqycgl);
+        double v1 = Math.abs(pjglw - dqycgl) / dqycgl;
+        if (v1 > 2) {
+            v1 = 0;
+        } else if (v1 > 1) {
+            v1 = 2 - v1;
+        } else {
+            v1 = 1 - v1;
+        }
+        day.setDqycglZql(v1 * 100);
+        day.setCdqycgl(cdqycgl);
+        double v2 = Math.abs(pjglw - cdqycgl) / cdqycgl;
+        if (v2 > 2) {
+            v2 = 0;
+        } else if (v2 > 1) {
+            v2 = 2 - v2;
+        } else {
+            v2 = 1 - v2;
+        }
+        day.setCdqycglZql(v2 * 100);
+        day.setLlcdqycgl(llcdqycgl);
+        double v3 = Math.abs(pjglw - llcdqycgl) / llcdqycgl;
+        if (v3 > 2) {
+            v3 = 0;
+        } else if (v3 > 1) {
+            v3 = 2 - v3;
+        } else {
+            v3 = 1 - v3;
+        }
+        day.setLlcdqycglZql(v3 * 100);
+    }
+    stationInfoMinService.saveOrUpdateBatch(byDate);
+}*/

ruoyi-admin/src/main/java/com/ruoyi/web/controller/JavaFunctionJobHandler2.java

@@ -2,6 +2,8 @@ package com.ruoyi.web.controller;
 
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.NumberUtil;
+import com.baomidou.mybatisplus.extension.service.IService;
 import com.ruoyi.ucp.entity.PointData;
 import com.ruoyi.ucp.entity.PointInfo;
 import com.ruoyi.ucp.entity.TurbineInfoDay;
@@ -9,17 +11,19 @@ import com.ruoyi.ucp.feign.AdapterApi;
 import com.ruoyi.ucp.util.CalcCache;
 import com.ruoyi.web.runner.ServiceGroup;
 import lombok.Delegate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 @Service
 public class JavaFunctionJobHandler2 {
 
+    public static final Logger logger = LoggerFactory.getLogger(JavaFunctionJobHandler.class);
+
     @Resource
     private AdapterApi adapter;
     @Resource
@@ -28,18 +32,6 @@ public class JavaFunctionJobHandler2 {
     @Resource
     private JavaFunctionJobHandler handler;
 
-    //风机日发电量平均风速累加推送
-    public void calcStationRfdlPjfsLjTs(DateTime begin, DateTime end) {
-        if (end.equals(DateUtil.beginOfDay(end))) return;
-
-        List<PointInfo> fsEntity = getEntity("AI066", "turbine");
-        getRawDataByEntity(fsEntity, goldenUri(), begin, end);
-
-        double fs = fsEntity.stream().mapToDouble(e -> averagePd(e.getPointDatas())).average().orElse(0);
-
-        adapter.writeHistoryBatch(mqttUri(), getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日平均风速", fs, 1));
-    }
-
     //场站上网购网厂用综合场用日发电量累加推送
     public void calcStationSwGwCyZhcyRfdlLjTs(DateTime begin, DateTime end) {
         if (end.equals(DateUtil.beginOfDay(end))) return;
@@ -48,10 +40,17 @@ public class JavaFunctionJobHandler2 {
         List<PointInfo> gwdlEt = getEntity("Z-FXYG-CX", "meter");
         List<PointInfo> cydlEt = getEntity("B-ZXYG-ZDB1", "meter");
         getRawDataByEntity(entity, goldenUri(), begin, end);
+        Map<String, Map<String, List<PointInfo>>> stationLineMap = entity.stream().collect(Collectors.groupingBy(PointInfo::getStationId, Collectors.groupingBy(PointInfo::getLineId)));
         Map<String, PointInfo> swdlMap = getRawDataByEntity(swdlEt, goldenUri(), begin, end, PointInfo::getStationId);
         Map<String, PointInfo> gwdlMap = getRawDataByEntity(gwdlEt, goldenUri(), begin, end, PointInfo::getStationId);
         Map<String, PointInfo> cydlMap = getRawDataByEntity(cydlEt, goldenUri(), begin, end, PointInfo::getStationId);
+
         swdlMap.forEach((stId, info) -> {
+            Map<String, List<PointInfo>> lineMap = stationLineMap.get(stId);
+            lineMap.forEach((lineId, pis) -> {
+                double rfdl = out2Zero(pis.stream().mapToDouble(pi -> calcHaDl(pi)).sum(), 0, 6000000);
+                getDataForZbs2(end, CalcCache.oneMap.get(lineId + "-日风机发电量"), rfdl, 0.001);
+            });
             double rfdl = out2Zero(entity.stream().mapToDouble(pi -> calcHaDl(pi)).sum(), 0, 6000000) / 1000;
             double swdl = out2Zero(calcHaDl2w(info), 0, 6000000) / 1000;
             double gwdl = out2Zero(calcHaDl(gwdlMap.get(stId)), 0, 6000000) / 1000;
@@ -63,52 +62,19 @@ public class JavaFunctionJobHandler2 {
             double zhcydl = rfdl + gwdl - swdl;
             getDataForZb(end, "区域集控.惠安风场.光耀计算.日综合场用电量", zhcydl);
             getDataForZb(end, "区域集控.惠安风场.光耀计算.月综合场用电量", tsSub(tsAdd("月发电量", "月购网电量"), "月上网电量"));
-            getDataForZb(end, "区域集控.惠安风场.光耀计算.年综合场用电量", tsSub(tsAdd("年发电量","年购网电量"), "年上网电量"));
-
-            getDataForZb(end, "区域集控.惠安风场.光耀计算.日场用电率", cydl/rfdl*100);
-            getDataForZb(end, "区域集控.惠安风场.光耀计算.日综合场用电率", zhcydl/rfdl*100);
-            getDataForZb(end, "区域集控.惠安风场.光耀计算.月场用电率", tsDiv("月场用电量","月发电量")*100);
-            getDataForZb(end, "区域集控.惠安风场.光耀计算.月综合场用电率", tsDiv("月综合场用电量","月发电量")*100);
-            getDataForZb(end, "区域集控.惠安风场.光耀计算.年场用电率", tsDiv("年场用电量","年发电量")*100);
-            getDataForZb(end, "区域集控.惠安风场.光耀计算.年综合场用电率", tsDiv("年综合场用电量","年发电量")*100);
+            getDataForZb(end, "区域集控.惠安风场.光耀计算.年综合场用电量", tsSub(tsAdd("年发电量", "年购网电量"), "年上网电量"));
+
+            getDataForZb(end, "区域集控.惠安风场.光耀计算.日场用电率", cydl / rfdl * 100);
+            getDataForZb(end, "区域集控.惠安风场.光耀计算.日综合场用电率", zhcydl / rfdl * 100);
+            getDataForZb(end, "区域集控.惠安风场.光耀计算.月场用电率", tsDiv("月场用电量", "月发电量") * 100);
+            getDataForZb(end, "区域集控.惠安风场.光耀计算.月综合场用电率", tsDiv("月综合场用电量", "月发电量") * 100);
+            getDataForZb(end, "区域集控.惠安风场.光耀计算.年场用电率", tsDiv("年场用电量", "年发电量") * 100);
+            getDataForZb(end, "区域集控.惠安风场.光耀计算.年综合场用电率", tsDiv("年综合场用电量", "年发电量") * 100);
         });
     }
-    ////场站限电五损
-    //public void calcStation5s(DateTime begin, DateTime end) {
-    //    if (end.equals(DateUtil.beginOfDay(end))) return;
-    //    //AGC
-    //    List<PointInfo> entityAgc = CalcCache.pointInfosMap.get("推送-booster-AGC-snap15s");
-    //    //出线
-    //    List<PointInfo> entityCx = CalcCache.pointInfosMap.get("推送-booster-出线-snap15s");
-    //    //可用功率
-    //    List<PointData> kyglpds = CalcCache.pointDatasMap.get("推送-booster-可用功率-snap15s");
-    //    PointInfo cxPi = entityCx.get(0);
-    //    List<PointData> cxPds = cxPi.getPointDatas();
-    //    List<PointData> czxd = calcStationXd2(entityAgc.get(0), cxPds, kyglpds, 0.01);
-    //    List<Double> xdl = new ArrayList<>();
-    //
-    //    for (int i = 0; i < cxPds.size(); i++) {
-    //        double v = kyglpds.get(i).getValue() * 1000 - cxPds.get(i).getValue() * cxPi.getCoef();
-    //        if (v < 0) v = 0;
-    //        if (czxd.get(i).isBooleanValue()) {
-    //            xdl.add(v);
-    //        } else {
-    //            xdl.add(0d);
-    //        }
-    //    }
-    //    double sumxdl = xdl.stream().mapToDouble(Double::doubleValue).sum() / 2400000;
-    //    //adapter.writeHistoryBatch(mqttUri(), getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl, 1));
-    //
-    //    getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", sumxdl/tsAdd(sumxdl, "日发电量")*100);
-    //    getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", tsDiv("月限电量",tsAdd("月限电量", "月发电量"))*100);
-    //    getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", tsDiv("年限电量",tsAdd("年限电量", "年发电量"))*100);
-    //    getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.日限电率").getValue());
-    //    getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.月限电率").getValue());
-    //    getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.年限电率").getValue());
-    //}
-
-
-    public void calcStation5s2(DateTime begin, DateTime end, double ssxs) {
+
+    //场站五项损失累加推送，依赖calcStationSwGwCyZhcyRfdlLjTs计算的日发电量
+    public void calcStation5sLjTs(DateTime begin, DateTime end, double ssxs) {
         if (end.equals(DateUtil.beginOfDay(end))) return;
         List<PointInfo> isFubing = getIsFubing(begin, end);
         Map<String, List<PointData>> isFubingMap = isFubing.stream().collect(Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas));
@@ -121,11 +87,11 @@ public class JavaFunctionJobHandler2 {
         //状态
         List<PointInfo> ztMapMap = CalcCache.pointInfosMap.get("推送-turbine-状态-snap15s");
         Map<String, Map<String, PointInfo>> ztMapMapInfos = pointInfos2MapMap2(ztMapMap);
-        List<TurbineInfoDay> byDate = new ArrayList<>();
+        Map<String, TurbineInfoDay> dayMap = getTurbineinfoMap(begin, entityFs);
         ztMapMapInfos.forEach((stId, ztMapInfo) -> ztMapInfo.forEach((wtId, ztInfo) -> {
             //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
             // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
-            TurbineInfoDay infoDay = new TurbineInfoDay();
+            TurbineInfoDay infoDay = dayMap.get(wtId);
             Map<String, Double> loss = getTurbinePowerLoss2(isFubingMap.get(wtId), ztInfo, fsMapMap.get(stId).get(wtId), glMapMap.get(stId).get(wtId));
             infoDay.setJhjxss(loss.get("jxss") * ssxs);
             infoDay.setFjhjxss(loss.get("gzss") * ssxs + loss.get("fdjcl") * ssxs + loss.get("sdtj") * ssxs);
@@ -135,7 +101,6 @@ public class JavaFunctionJobHandler2 {
             infoDay.setGzss(loss.get("gzss") * ssxs);
             infoDay.setXnss(loss.get("xnss") * ssxs + loss.get("djss") * ssxs);
             //infoDay.setLlfdl(infoDay.getRfdl() + infoDay.getJhjxss() + infoDay.getFjhjxss() + infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
-            byDate.add(infoDay);
         }));
 
         //AGC
@@ -161,38 +126,261 @@ public class JavaFunctionJobHandler2 {
             }
         }
         //可用功率算的限电量
-        double sumxdl = xdl.stream().mapToDouble(Double::doubleValue).sum() / 2400/1000;
-        adapter.writeHistoryBatch(mqttUri(), getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl));
-        getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", sumxdl/tsAdd(sumxdl, "日发电量")*100);
-        getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", tsDiv("月限电量",tsAdd("月限电量", "月发电量"))*100);
-        getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", tsDiv("年限电量",tsAdd("年限电量", "年发电量"))*100);
+        double sumxdl = xdl.stream().mapToDouble(Double::doubleValue).sum() / 2400 / 1000;
+        //adapter.writeHistoryBatch(mqttUri(), getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl));
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", sumxdl / tsAdd(sumxdl, "日发电量") * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", tsDiv("月限电量", tsAdd("月限电量", "月发电量")) * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", tsDiv("年限电量", tsAdd("年限电量", "年发电量")) * 100);
         getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.日限电率").getValue());
         getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.月限电率").getValue());
         getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.年限电率").getValue());
+        Collection<TurbineInfoDay> values = dayMap.values();
         //可用功率算的总损失电量(除限电)
-        double sumZssdl = zssdl.stream().mapToDouble(Double::doubleValue).sum() / 2400/1000;
+        double sumZssdl = zssdl.stream().mapToDouble(Double::doubleValue).sum() / 2400 / 1000;
         //理论功率算的总损失电量(除限电) xd + fjh + jh + xn + sl
-        double zsssum = byDate.stream().mapToDouble(tid -> tid.getFjhjxss() + tid.getJhjxss() + tid.getXnss()+tid.getSlss()).sum();
+        double zsssum = values.stream().mapToDouble(tid -> tid.getFjhjxss() + tid.getJhjxss() + tid.getXnss() + tid.getSlss()).sum();
+        double xdsum = values.stream().mapToDouble(TurbineInfoDay::getXdss).sum();
+        //可用功率算的限电
+        double sum = xdl.stream().mapToDouble(Double::doubleValue).sum() / 2400;
+        double xdxs = xdsum == 0d ? 0d : sum / xdsum;
         double zssXs = zsssum == 0d ? 0d : sumZssdl / zsssum;
-        double jhjxss = 0,fjhjxss = 0,xnss = 0,djss = 0,gzss = 0,slss = 0;
-        for (TurbineInfoDay tid : byDate) {
-            jhjxss+=tid.getJhjxss();
-            fjhjxss+=tid.getFjhjxss();
-            xnss+=tid.getXnss();
-            djss+=tid.getDjss();
-            gzss+=tid.getGzss();
-            slss+=tid.getSlss();
+
+        double jhjxss = 0, fjhjxss = 0, xnss = 0, djss = 0, gzss = 0, slss = 0;
+        for (TurbineInfoDay tid : values) {
+            tid.setXdss((tid.getXdss() - tid.getDjss()) * xdxs);
+            //
+            tid.setJhjxss(tid.getJhjxss() * zssXs);
+            tid.setFjhjxss(tid.getFjhjxss() * zssXs);
+            tid.setXnss(tid.getXnss() * zssXs);
+            tid.setDjss(tid.getDjss() * zssXs);
+            tid.setGzss(tid.getGzss() * zssXs);
+            tid.setSlss(tid.getSlss() * zssXs);
+            tid.setLlfdl(tid.getRfdl() + tid.getXdss() + tid.getFjhjxss() + tid.getJhjxss() + tid.getXnss());
+
+            jhjxss += tid.getJhjxss();
+            fjhjxss += tid.getFjhjxss();
+            xnss += tid.getXnss();
+            djss += tid.getDjss();
+            gzss += tid.getGzss();
+            slss += tid.getSlss();
         }
-        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日故障损失电量", gzss*zssXs);
-        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日计划检修损失电量", jhjxss*zssXs);
-        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日受累损失电量", (djss+slss)*zssXs);
-        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日损失电量", sumZssdl);
+        IService<TurbineInfoDay> service = serviceGroup.getService(TurbineInfoDay.class);
+        //service.saveOrUpdateBatch(values);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日故障损失电量", gzss * zssXs);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日计划检修损失电量", jhjxss * zssXs);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日受累损失电量", (djss + slss) * zssXs);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.日损失电量", sumZssdl);
         getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电损失电量", sumxdl);
-        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日性能损失电量", xnss*zssXs);
-        getDataForZb(end, "区域集控.惠安风场.光耀计算.日性能损失率", (xnss*zssXs)/tsAdd("日性能损失电量", "日发电量")*100);
-        getDataForZb(end, "区域集控.惠安风场.光耀计算.月性能损失率", tsDiv("月限电量",tsAdd("月限电量", "月发电量"))*100);
-        getDataForZb(end, "区域集控.惠安风场.光耀计算.年性能损失率", tsDiv("年限电量",tsAdd("年限电量", "年发电量"))*100);
-        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.月损失电量", tsAdd("月限电量","月计划检修损失电量","月故障损失电量","月性能损失电量","月受累损失电量"));
-        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.年损失电量", tsAdd("年限电量","年计划检修损失电量","年故障损失电量","年性能损失电量","年受累损失电量"));
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日性能损失电量", xnss * zssXs);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.日性能损失率", (xnss * zssXs) / tsAdd("日性能损失电量", "日发电量") * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.月性能损失率", tsDiv("月限电量", tsAdd("月限电量", "月发电量")) * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.年性能损失率", tsDiv("年限电量", tsAdd("年限电量", "年发电量")) * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.月损失电量", tsAdd("月限电量", "月计划检修损失电量", "月故障损失电量", "月性能损失电量", "月受累损失电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.年损失电量", tsAdd("年限电量", "年计划检修损失电量", "年故障损失电量", "年性能损失电量", "年受累损失电量"));
+
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.日理论发电量", tsAdd("日发电量", "日损失电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.月理论发电量", tsAdd("月发电量", "月损失电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.年理论发电量", tsAdd("年发电量", "年损失电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.日风能利用率", tsDiv("日发电量", "日理论发电量") * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.月风能利用率", tsDiv("月发电量", "月理论发电量") * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.年风能利用率", tsDiv("年发电量", "年理论发电量") * 100);
+    }
+
+    //线路发电量耗电量主变发电量累加推送
+    public void calcXlZbFdlLjTs(DateTime begin, DateTime end) {
+        if (end.equals(DateUtil.beginOfDay(end))) return;
+        DateTime begin0 = DateUtil.offsetDay(begin, -1);
+        List<PointInfo> entity0 = getEntity("Z-ZXYG-JX", "meter");
+        filterList(entity0, pi -> "".equals(pi.getProjectId()));
+        getRawDataByEntity(entity0, goldenUri(), begin0, begin);
+        List<PointInfo> entity = getEntity("Z-ZXYG-JX", "meter");
+        filterList(entity, pi -> "".equals(pi.getProjectId()));
+        getRawDataByEntity(entity, goldenUri(), begin, end);
+        //线路耗电量
+        List<PointInfo> entityHdl = getEntity("Z-FXYG-JX", "meter");
+        filterList(entityHdl, pi -> "".equals(pi.getProjectId()));
+        getRawDataByEntity(entityHdl, goldenUri(), begin, end);
+
+        Map<String, PointInfo> fdlMap0 = list2Map(entity0, PointInfo::getLineId);
+        Map<String, PointInfo> fdlMap = list2Map(entity, PointInfo::getLineId);
+        Map<String, PointInfo> hdlMap = list2Map(entityHdl, PointInfo::getLineId);
+
+        for (PointInfo day : entity) {
+            String lineId = day.getLineId();
+            double fdl = 0;
+            try {
+                double pdsfdl0 = fdlMap0.get(lineId).getPointDatas().stream().mapToDouble(PointData::getValue).max().orElse(0);
+                double pdsfdl = day.getPointDatas().stream().mapToDouble(PointData::getValue).max().orElse(0);
+                fdl = out2Zero(NumberUtil.round((pdsfdl - pdsfdl0), 2).doubleValue() * day.getCoef(), 0, 90000);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            double hdl = out2Zero(calcHaDl(hdlMap.get(lineId)), 0, 90000);
+            getDataForZbs2(end, CalcCache.oneMap.get(lineId + "-日发电量"), fdl * 0.001);
+            getDataForZbs2(end, CalcCache.oneMap.get(lineId + "-日耗电量"), hdl * 0.001);
+        }
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.集电线日发电量", tsAdd("集电一线日发电量", "集电二线日发电量", "集电三线日发电量", "集电四线日发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.集电线月发电量", tsAdd("集电一线月发电量", "集电二线月发电量", "集电三线月发电量", "集电四线月发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.集电线年发电量", tsAdd("集电一线年发电量", "集电二线年发电量", "集电三线年发电量", "集电四线年发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.日线路损耗", tsSub("日发电量", "集电线日发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.月线路损耗", tsSub("月发电量", "集电线月发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.年线路损耗", tsSub("年发电量", "集电线年发电量"));
+        System.out.println();
+    }
+
+    //风机平均风速累加推送
+    public void calcStationPjfsLjTs(DateTime begin, DateTime end) {
+        if (end.equals(DateUtil.beginOfDay(end))) return;
+
+        List<PointInfo> fsEntity = getEntity("AI066", "turbine");
+        getRawDataByEntity(fsEntity, goldenUri(), begin, end);
+        double yf = fsEntity.stream().mapToLong(e -> calcMatchDuration(e.getPointDatas(), pd -> pd.getValue() > 3 && pd.getValue() < 18)).average().orElse(0.0);
+        yf = yf / (1000 * 60 * 60d);
+
+        double fs = fsEntity.stream().mapToDouble(e -> averagePd(e.getPointDatas())).average().orElse(0);
+
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日平均风速", fs);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日有效风时数", yf);
+    }
+
+    //场站利用小时累加推送
+    public void calcStationLyxsLjTs(DateTime begin, DateTime end) {
+        //装机容量
+        List<PointInfo> entityAiZt = getEntity("AI422", "state");
+        double zjrl = entityAiZt.stream().mapToDouble(pi -> pi.getSpare2() * pi.getCoef()).sum() / 1000;
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日利用小时", tsDiv("日发电量", zjrl));
+    }
+
+    //场站运行小时累加推送
+    public void calcStationYxxsLjTs(DateTime begin, DateTime end) {
+        //状态测点
+        List<PointInfo> entityMxzt = getEntity("MXZT", "turbine");
+        getRawDataByEntity(entityMxzt, taosUri(), begin, end);
+        double yxxs = 0, gzxs = 0, jxxs = 0, djxs = 0, tjxs = 0, gzcs = 0;
+        double klyl = 0;
+        for (PointInfo info : entityMxzt) {
+            //统计
+            Map<String, Map<Double, Long>> dlmm = calcStateDurationFrequency(info.getPointDatas());
+            Map<Double, Long> durations = dlmm.get("duration");
+            Map<Double, Long> frequency = dlmm.get("frequency");
+            yxxs += durations.getOrDefault(2.0, 0L);
+            Long gzt = durations.getOrDefault(4.0, 0L);
+            gzxs += gzt;
+            jxxs += durations.getOrDefault(6.0, 0L);
+            djxs += durations.getOrDefault(0.0, 0L);
+            tjxs += durations.getOrDefault(1.0, 0L);
+            gzcs += frequency.getOrDefault(4.0, 0L);
+            klyl += (24 - gzt / (1000 * 60 * 60d)) / 24;
+        }
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日运行小时", yxxs / (1000 * 60 * 60d) / entityMxzt.size());
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日风电机组故障停运时长", gzxs / (1000 * 60 * 60d) / entityMxzt.size());
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日计划停机时长", jxxs / (1000 * 60 * 60d) / entityMxzt.size());
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日技术待机时长", djxs / (1000 * 60 * 60d) / entityMxzt.size());
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日平均停机时长", tjxs / (1000 * 60 * 60d) / entityMxzt.size());
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.日自然因素停运时长", 0);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.月自然因素停运时长", 0);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.年日自然因素停运时长", 0);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日风电机组故障停运次数", gzcs);
+        getDataForZbs5(end, "区域集控.惠安风场.光耀计算.日风电机组设备可利用率", klyl / entityMxzt.size() * 100);
+
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.日运行暴露率", tsDiv("日运行小时", 24d - tsAdd("日风电机组故障停运时长", "日计划停机时长")) * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.月运行暴露率", tsDiv("月运行小时", 24d * end.dayOfMonth() - tsAdd("月风电机组故障停运时长", "月计划停机时长")) * 100);
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.年运行暴露率", tsDiv("年运行小时", 24d * end.dayOfYear() - tsAdd("年风电机组故障停运时长", "年计划停机时长")) * 100);
+    }
+
+    //场站空气密度平均气温累加推送
+    public void calcStationKqmdLjTs(DateTime begin, DateTime end) {
+        //环境温度
+        List<PointInfo> entityHjwd = getEntity("AI072", "turbine");
+        getRawDataByEntity(entityHjwd, goldenUri(), begin, end);
+        Map<String, List<PointInfo>> hjwdsMap = entityHjwd.stream().collect(Collectors.groupingBy(PointInfo::getStationId));
+        //测风塔温度
+        List<PointInfo> wdEt = getEntity("FCCFTWD", "station");
+        List<PointInfo> yqEt = getEntity("FCCFTYQ", "station");
+        Map<String, PointInfo> rawWd = getRawDataByEntity(wdEt, goldenUri(), begin, end, PointInfo::getStationId);
+        Map<String, PointInfo> secYq = getRawDataByEntity(yqEt, goldenUri(), begin, end, PointInfo::getStationId);
+
+        hjwdsMap.forEach((stId, pis) -> {
+            //环境温度
+            List<PointInfo> hjwdInfos = hjwdsMap.get(stId);
+            List<Double> hjwds = new ArrayList<>();
+            for (PointInfo wd : hjwdInfos) {
+                double v = wd.getPointDatas().stream().filter(p -> p.getValue() != 0.0).mapToDouble(PointData::getValue).average().orElse(0.0);
+                if (v > 0 && v < 83) hjwds.add(v);
+            }
+            double hjwd = hjwds.stream().mapToDouble(Double::doubleValue).average().orElse(0.0);
+            //测风塔温度
+            List<PointData> wdData = rawWd.get(stId).getPointDatas();
+            List<PointData> yqData = secYq.get(stId).getPointDatas();
+            double wd = wdData.stream().mapToDouble(PointData::getValue).average().orElse(0d);
+            double yq = yqData.stream().mapToDouble(PointData::getValue).average().orElse(0d);
+            double kqmd = 1.293 * (yq * 100 / 101325) * (273.15 / (wd + 273.15));
+            getDataForZbs4(end, "区域集控.惠安风场.光耀计算.日平均气温", hjwd);
+            getDataForZbs4(end, "区域集控.惠安风场.光耀计算.日平均空气密度", kqmd);
+        });
+    }
+
+    //主变耗电量累加推送
+    public void calcMeterDlHdlLjTs(DateTime begin, DateTime end) {
+        //1号SVG B-ZXYG-SVG1 B-FXYG-SVG1
+        double svg1Hdl = calcMeterSimple("B-ZXYG-SVG1", begin, end);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号SVG日耗电量", svg1Hdl);
+        //2号SVG B-ZXYG-SVG2 B-FXYG-SVG2
+        double svg2Hdl = calcMeterSimple("B-ZXYG-SVG2", begin, end);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号SVG日耗电量", svg2Hdl);
+        //1号接地变兼站用变 B-ZXYG-ZDB1 B-FXYG-ZDB1
+        double zyb1Hdl = calcMeterSimple("B-ZXYG-ZDB1", begin, end);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号站用变日耗电量", zyb1Hdl);
+        //2号接地变 B-ZXYG-ZDB1 B-FXYG-ZDB1
+        double jdb2Hdl = calcMeterSimple("B-ZXYG-ZDB2", begin, end);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号接地变日耗电量", jdb2Hdl);
+        //1号主变低压侧正向有功
+        double zbdyc1Hdl = calcMeterSimple("B-ZXYG-ZBDYC1", begin, end);
+        double zbdyc1Fdl = calcMeterSimple("B-FXYG-ZBDYC1", begin, end);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号主变低压侧日发电量", zbdyc1Fdl);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号主变低压侧日耗电量", zbdyc1Hdl);
+        //1号主变高压侧正向有功 B-ZXYG-ZBGYC1
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号主变高压侧日发电量", 0);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号主变高压侧日耗电量", 0);
+        //2号主变低压侧正向有功
+        double zbdyc2Hdl = calcMeterSimple("B-ZXYG-ZBDYC2", begin, end);
+        double zbdyc2Fdl = calcMeterSimple("B-FXYG-ZBDYC2", begin, end);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号主变低压侧日发电量", zbdyc2Fdl);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号主变低压侧日耗电量", zbdyc2Hdl);
+        //2号主变高压侧正向有功
+        double zbgyc2Hdl = calcMeterSimple("B-ZXYG-ZBGYC2", begin, end);
+        double zbgyc2Fdl = calcMeterSimple("B-FXYG-ZBGYC2", begin, end);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号主变高压侧日发电量", zbgyc2Fdl);
+        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号主变高压侧日耗电量", zbgyc2Hdl);
+
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.1号主变日损耗电量", tsSub("1号主变低压侧日发电量", "1号主变高压侧日发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.2号主变日损耗电量", tsSub("2号主变低压侧日发电量", "2号主变高压侧日发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.主变日损耗合计", tsAdd("1号主变日损耗电量", "2号主变日损耗电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.1号主变月损耗电量", tsSub("1号主变低压侧月发电量", "1号主变高压侧月发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.2号主变月损耗电量", tsSub("2号主变低压侧月发电量", "2号主变高压侧月发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.主变月损耗合计", tsAdd("1号主变月损耗电量", "2号主变月损耗电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.1号主变年损耗电量", tsSub("1号主变低压侧年发电量", "1号主变高压侧年发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.2号主变年损耗电量", tsSub("2号主变低压侧年发电量", "2号主变高压侧年发电量"));
+        getDataForZb(end, "区域集控.惠安风场.光耀计算.主变年损耗合计", tsAdd("1号主变年损耗电量", "2号主变年损耗电量"));
+    }
+
+
+    //风机平均风速实时推送
+    public void calcStationPjfsSsTs() {
+
+        List<PointInfo> fsEntity = getEntity("AI066", "turbine");
+        getLatestByEntity(fsEntity, goldenUri());
+
+        double fs = fsEntity.stream().mapToDouble(e -> e.getPointDatas().get(0).getValue()).average().orElse(0);
+
+        PointData zb = getDataForZb(DateUtil.date(), "区域集控.惠安风场.光耀计算.平均风速", fs);
+        adapter.writeHistoryBatch(mqttUri(), Collections.singletonList(zb));
+    }
+
+    public void setDatas(DateTime begin, DateTime end) {
+        List<PointData> dataList = CalcCache.pointDataMap.values().stream().filter(pd -> pd.getTagName().startsWith("区域集控.惠安风场.光耀计算.")).collect(Collectors.toList());
+        adapter.writeHistoryBatch(mqttUri(), dataList);
+        System.out.println();
     }
 }

ruoyi-admin/src/test/java/com/ruoyi/NewTests.java

@@ -5,6 +5,7 @@ import cn.hutool.core.date.DateRange;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.thread.ThreadUtil;
+import cn.hutool.core.util.NumberUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.LambdaUtils;
 import com.baomidou.mybatisplus.core.toolkit.support.LambdaMeta;
@@ -62,16 +63,6 @@ public class NewTests {
         //example.setLocationRelativeTo(null);
         //example.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
         //example.setVisible(true);
-        List<Double> xdl = new ArrayList<>();
-        xdl.add(0.0);
-        xdl.add(1.0);
-        xdl.add(2.0);
-        xdl.add(3.0);
-        xdl.add(4.0);
-        xdl.add(5.0);
-        xdl.add(6.0);
-        xdl.add(7.0);
-        xdl.subList(Math.max(0, 3 - 4),3+1);
         //Double v = xdl.get(0);
         //v = v + 3;
         //int i = DateUtil.endOfMonth(DateUtil.date()).dayOfMonth();
@@ -82,6 +73,8 @@ public class NewTests {
         //int i = end.minute() / 15 * 15;
         //end.setMinutes(i);
         //DateTime begin = DateUtil.offsetMinute(end, -15);
+        double v = NumberUtil.add(null, 5).doubleValue();
+        double div = NumberUtil.div(50, 0);
         System.out.println();
     }
 
@@ -123,7 +116,7 @@ public class NewTests {
         //        task.calcTurbineSsfsQx(date);
         //        task.ambientTemperature();
 
-                task.calcTurbine5s2(date);
+                //task.calcTurbine5s2(date);
         task.calcLineRfdl(date);
 
         //        task.calcStationZhcyRfDl(date,"GJNY_SXGS_XZ_FDC_STA");
@@ -229,8 +222,8 @@ public class NewTests {
     @Test
     public void test3() {
         // 创建日期范围生成器
-        DateTime start = DateUtil.parse("2025-09-10");
-        DateTime stop = DateUtil.parse("2025-09-10");
+        DateTime start = DateUtil.parse("2025-10-10 00:00:00");
+        DateTime stop = DateUtil.parse("2025-10-11 00:00:00");
         //DateRange range = DateUtil.range(start, end, DateField.MONTH);
         DateRange range = DateUtil.range(start, stop, DateField.HOUR_OF_DAY);
         for (DateTime begin : range) {
@@ -350,8 +343,8 @@ public class NewTests {
 
     @Test
     public void test9() {
-        DateTime date = DateUtil.date();
-        //Date date = DateUtil.parse("2025-01-09");
+        //DateTime date = DateUtil.date();
+        Date date = DateUtil.parse("2025-10-03");
         //task.calcLineRfdlSameDay_ha();
         //task.calcStationSwGwCyDlSameDay_ha();
         //task.calcStationZhcyRfDlSameDay();
@@ -359,15 +352,15 @@ public class NewTests {
         //task.calcTurbine5s2_ha(date);
         //task.calcStationRfdlFj(date);
         //task.calcLineRfdl_ha(date);
-        //task.haxdRecalc(date);
-        task.calcStationZhcyRfDl_ha(date);
+        task.haxdRecalc(date);
+        //task.calcStationZhcyRfDl_ha(date);
         //task.calcHaBbHz(date);
     }
 
     @Test
     public void test10() {
-        DateTime start = DateUtil.parse("2025-09-01");
-        DateTime end = DateUtil.parse("2025-09-01");
+        DateTime start = DateUtil.parse("2025-10-01");
+        DateTime end = DateUtil.parse("2025-10-10");
         DateRange range = DateUtil.range(start, end, DateField.DAY_OF_YEAR);
         for (DateTime date : range) {
             System.out.println(DateUtil.date() + "：" + date);
@@ -397,21 +390,21 @@ public class NewTests {
             //task.calcStationKqmd(date);
             //
             //task.calcStationKydlzql(date);
-            //task.calcTurbineJfplFxYxfssBll(date);
             //task.calcTurbineLyxs2(date,10);
 
             //task.calcMeterDlHdl(date);
-            //DateTime t2 = DateUtil.offsetMinute(date,-1);
-            //DateTime t1 = DateUtil.beginOfDay(t2);
+            DateTime t2 = DateUtil.offsetMinute(date,-1);
+            DateTime t1 = DateUtil.beginOfDay(t2);
             //DateTime b1 = DateUtil.offsetDay(date, -1);
             DateTime b2 = DateUtil.endOfDay(date);
             ////计算综合厂用电量
             //task.calcStationZhcyRfDl_ha(b1, b2);
-            //task.calcTurbineRFDL(t1, t2);
+            task.calcTurbineRFDL(t1, t2);
             //task.calcStationRfdlFj(b1);
             //task.calcHaBbHz(date);
-            task.calcHaBbHzSs(date, b2);
+            //task.calcHaBbHzSs(date, b2);
             //task.calcRYNxdl(b, date);
+            //task.calcTurbineJfplFxYxfssBll(date, b2);
 
             //task.calcTurbineStateMin(date);
         }
@@ -439,12 +432,13 @@ public class NewTests {
 
     @Test
     public void test13() {
-        DateTime end = DateUtil.date();
-        DateTime begin = DateUtil.beginOfDay(end);
-        DateTime date = DateUtil.date();
         DateTime yesterday = DateUtil.yesterday();
+        yesterday = DateUtil.offsetDay(yesterday, -1);
+        DateTime end = DateUtil.endOfDay(yesterday);
+        DateTime date = DateUtil.date();
+        DateTime begin = DateUtil.beginOfDay(date);
         //DateTime begin = DateUtil.beginOfDay(end);
-        //task.calcTurbineRFDL(begin, end);
+        task.calcTurbineRFDL(begin, date);
         //task.calcTurbineStateMin(begin, end);
         //task.calcTurbineLyxs(begin);
         //task.calcStationCftfsfxQfxdl(begin, end);
@@ -463,14 +457,14 @@ public class NewTests {
 
     @Test
     public void test15() {
-        DateTime begin = DateUtil.parse("2025-09-18");
-        DateTime end = DateUtil.parse("2025-09-18");
+        DateTime begin = DateUtil.parse("2025-10-09");
+        DateTime end = DateUtil.parse("2025-10-09");
         DateRange range = DateUtil.range(begin, end, DateField.DAY_OF_YEAR);
         for (DateTime begin1 : range) {
             DateTime end1 = DateUtil.endOfDay(begin1);
             DateTime date = DateUtil.offsetDay(begin1,1);
             //task.calcStationSwGwCyRdl_ha(date);
-            task.abc(begin1);
+            //task.abc(begin1);
             //task.calcTurbineLyxs(begin1, 10);
             //task.calcRYNxdl(begin1, end1);
             //task.calcMtMonth(end1);
@@ -482,7 +476,7 @@ public class NewTests {
             //task.calcMeterDlHdl(date);
 
 
-            task.calcTurbineFxTest(date);
+            //task.calcTurbineFxTest(date);
             //task.calcTurbineJfplFxYxfssBll(date);
             //task.calcStationKydlzql(date);
             //task.calcStationCftfsfxQfxdl(date);
@@ -496,7 +490,7 @@ public class NewTests {
             //task.calcHaBbHzSs(begin1, end1);
             //task.calcStationSwdl(begin, end);
             //区域集控.惠安风场.一期本期故障损失电量
-            //task.calcHaBbHz(date);
+            task.calcHaBbHz(date);
 
             //task.calcStationZhcyRfDl_ha(date);
             //task.calcTurbineRFDL(begin1, end1);
@@ -551,8 +545,8 @@ public class NewTests {
         DateTime begin = DateUtil.parse("2025-09-24");
         DateTime end = DateUtil.endOfDay(begin);
         task.calcTurbine5s(begin, end, 0.1);
-        //task.calcHaBbHzSs(begin, end);
-        //task.calcHaBbHz(begin);
+        task.calcHaBbHzSs(begin, end);
+        task.calcHaBbHz(begin);
     }
 
     @Test
@@ -606,17 +600,17 @@ public class NewTests {
 
         task.createBimap();
         task.calcNYData(begin);
-        task2.calcStation5s(begin, end);
+        //task2.calcStation5s(begin, end);
         task.zeroPush(end);
     }
 
     @Test
     public void test6() {
-        DateTime begin = DateUtil.parse("2025-09-17 17:00:00");
-        DateTime end = DateUtil.parse("2025-09-17 17:15:00");
+        DateTime begin = DateUtil.parse("2025-10-10 18:00:00");
+        DateTime end = DateUtil.parse("2025-10-11 00:00:00");
         DateTime minEnd = begin;
-        task.createBimap();
-        task.calcNYData(begin);
+        //task.createBimap();
+        //task.calcNYData(begin);
         while (minEnd.isBefore(end)) {
             minEnd = DateUtil.offsetMinute(begin, 15);
             //task.calcTurbinePjfsPjglKyglLlglMin(minEnd);
@@ -626,7 +620,9 @@ public class NewTests {
             //task.calcStationSjglAgcPjfsHjwdDlMin(begin);
             //task.calcStationYcgl_ha(begin,minEnd);
             //task.calcStationSwdl(begin, minEnd);
-            task2.calcStation5s(begin, minEnd);
+            task.calcStationSwdl(begin, minEnd);
+            task.calcStationYcgl_ha(begin, minEnd);
+            task.calcStationZql(begin, minEnd);
 
             System.out.println(begin + "," + minEnd);
             begin = minEnd;
@@ -635,8 +631,12 @@ public class NewTests {
 
     @Test
     public void test66() {
+        //calcStationKydlzql，calcStationYcgl_ha
+        //DateTime date = DateUtil.parse("2025-10-13 11:20:00");
+        //task2.calcStation5s(begin, end, agcSnap.get(0), cxSanp.get(0), kyglSnap);
+        DateTime date = DateUtil.date();
 
-        DateTime end = DateUtil.beginOfMinute(DateUtil.date());
+        DateTime end = DateUtil.beginOfMinute(date);
         end.setMinutes(end.minute() / 15 * 15);
         DateTime begin = DateUtil.beginOfDay(end);
 
@@ -644,9 +644,32 @@ public class NewTests {
         task.calcNYData(DateUtil.offsetDay(begin,-1));
         task.getDatas(begin, end);
 
-        //task2.calcStation5s(begin, end, agcSnap.get(0), cxSanp.get(0), kyglSnap);
-        task.calcStation5s(begin, end);
+        task2.calcStationSwGwCyZhcyRfdlLjTs(begin, end);
+        //依赖日发电量
+        task2.calcStation5sLjTs(begin, end,0.1);
+        task2.calcXlZbFdlLjTs(begin, end);
+        task2.calcStationPjfsLjTs(begin, end);
+
+        task2.calcStationLyxsLjTs(begin, end);
+        task2.calcStationYxxsLjTs(begin, end);
+        task2.calcStationKqmdLjTs(begin, end);
+        task2.calcMeterDlHdlLjTs(begin, end);
+        //task2.calcStationPjfsSsTs();
+        //task2.setDatas(begin, end);
+        System.out.println();
+    }
+    @Test
+    public void test67() {
+        DateTime date = DateUtil.date();
 
-        task.zeroPush(end);
+        DateTime end = DateUtil.beginOfMinute(date);
+        end.setMinutes(end.minute() / 15 * 15);
+        DateTime begin = DateUtil.beginOfDay(end);
+
+        task.createBimap();
+        task.calcNYData(DateUtil.offsetDay(begin,-1));
+
+        task2.calcStationKqmdLjTs(begin, end);
+        System.out.println();
     }
 }

ruoyi-framework/src/main/java/com/ruoyi/framework/config/SecurityConfig.java

@@ -108,7 +108,7 @@ public class SecurityConfig extends WebSecurityConfigurerAdapter {
                 // 过滤请求
                 .authorizeRequests()
                 // 对于登录login 注册register 验证码captchaImage 允许匿名访问
-                .antMatchers("/login", "/register", "/captchaImage","/predict/**").permitAll()
+                .antMatchers("/login", "/register", "/captchaImage","/predict/**","/debug/**").permitAll()
                 .antMatchers(HttpMethod.PUT, "/monitor/**").permitAll()
                 // 静态资源，可匿名访问
                 .antMatchers(HttpMethod.GET, "/", "/*.html", "/**/*.html", "/**/*.css", "/**/*.js", "/profile/**").permitAll()