获取1分钟平均风速,计算1分钟理论发电量

electricity/meter/build.gradle

@@ -54,5 +54,8 @@ dependencies {
 
 
 
+
+
+
 }
 

electricity/meter/src/main/java/com/gyee/gaia/meter/entity/ModelPowerDetails.java

@@ -0,0 +1,46 @@
+package com.gyee.gaia.meter.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 型号功率表
+ */
+@TableName("pro_basic_model_power_details")
+@Data
+public class ModelPowerDetails implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 型号
+     */
+    private String id;
+
+    /**
+     * 型号id
+     */
+    private String modelId;
+
+    /**
+     * 风速(0.01)
+     */
+    private double speed;
+
+    /**
+     * 理论功率
+     */
+    private double theoryPower;
+
+    /**
+     * 保证功率
+     */
+    private double ensurePower;
+
+
+
+
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/entity/vo/MeterInfoVo.java

@@ -12,13 +12,21 @@ import java.math.BigDecimal;
 @Data
 public class MeterInfoVo {
 
+    //名称
     private String name;
+    //编码
     private String nemCode;
+    //日期
     private DateTime date;
+    //开始日期
     private DateTime startTime;
+    //结束日期
     private DateTime endTime;
+    //起码
     private BigDecimal startCode;
+    //止码
     private BigDecimal endCode;
+    //电量
     private BigDecimal rdl;
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/entity/vo/MeterVO.java

@@ -11,7 +11,9 @@ import java.math.BigDecimal;
  **/
 @Data
 public class MeterVO {
+    //日期
     public DateTime date;
+    //字符串日期
     public String timestr;
 
     //日发电量
@@ -29,7 +31,7 @@ public class MeterVO {
     public BigDecimal yfdl;
     //总风场年发电量
     public BigDecimal nfdl;
-
+    //总风场日上网电量
     public BigDecimal swdl;
 
 

electricity/meter/src/main/java/com/gyee/gaia/meter/mapper/ModelPowerDetailsMapper.java

@@ -0,0 +1,14 @@
+package com.gyee.gaia.meter.mapper;
+
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.gyee.gaia.meter.entity.ModelPowerDetails;
+import com.gyee.gaia.meter.entity.TestingPoint;
+import org.apache.ibatis.annotations.Mapper;
+
+
+@Mapper
+public interface ModelPowerDetailsMapper extends BaseMapper<ModelPowerDetails> {
+
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/iService/IModelPowerDetailsService.java

@@ -0,0 +1,14 @@
+package com.gyee.gaia.meter.service.iService;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gyee.gaia.meter.entity.ModelPowerDetails;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 04: 27
+ **/
+
+
+public interface IModelPowerDetailsService extends IService<ModelPowerDetails> {
+
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/impl/ModelPowerDetailsServiceImpl.java

@@ -0,0 +1,15 @@
+package com.gyee.gaia.meter.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gyee.gaia.meter.entity.ModelPowerDetails;
+import com.gyee.gaia.meter.mapper.ModelPowerDetailsMapper;
+import com.gyee.gaia.meter.service.iService.IModelPowerDetailsService;
+import org.springframework.stereotype.Service;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 04: 27
+ **/
+@Service
+public class ModelPowerDetailsServiceImpl extends ServiceImpl<ModelPowerDetailsMapper, ModelPowerDetails> implements IModelPowerDetailsService {
+}

electricity/meter/src/main/java/com/gyee/gaia/meter/service/saveTDengine/TDLLFDLTest.java

@@ -0,0 +1,513 @@
+package com.gyee.gaia.meter.service.saveTDengine;
+
+import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.date.LocalDateTimeUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.gyee.gaia.meter.adapter.Adapter;
+import com.gyee.gaia.meter.entity.*;
+import com.gyee.gaia.meter.mapper.TDLineFDL15MinMapper;
+import com.gyee.gaia.meter.service.impl.*;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.sql.SQLOutput;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Author: malijun
+ * Data  : 2023: 04: 27
+ **/
+@SpringBootTest
+class TDLLFDLTest {
+
+    @Resource
+    TDLineFDL15MinServiceImpl tdLineFDL15MinService;
+    @Resource
+    TDLineFDL15MinMapper tdLineFDL15MinMapper;
+
+    @Resource
+    Adapter adapter;
+    @Resource
+    PowerStationServiceImpl powerStationService;
+    @Resource
+    MeterPointServiceImpl meterPointService;
+    @Resource
+    ProMeterLineFDL15MinServiceImpl proMeterLineFDL15MinService;
+
+
+    @Value("${start.time}")
+    private String startTimeString;
+    @Value("${end.time}")
+    private String endTimeString;
+
+
+    /**
+     * 保存taos(根据超级表自动创建子表)
+     */
+    @Test
+    void saveSaveLineFDL15Min() {
+
+        //1,查询所有风电场
+        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>()
+                .like("nem_code", "_FDC_"));
+
+        for (PowerStation powerStation : powerStationList) {
+            //2,根据场站ID,测点类型得到集电线路发电量的测点
+            List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .eq("windpowerstation_id", powerStation.getId())
+                    .eq("property", "CD")
+                    .eq("meter_type", "线路")
+                    .like("meter_class", "集电线路")
+            );
+
+            //3,遍历测点,拿到每个测点的nem_code
+            for (MeterPoint meterPoint : meterPointList) {
+                System.out.println(meterPoint);
+                //获取测点code
+                String pointcode = meterPoint.getNemCode();
+                String pointcode2 = pointcode.replace(".NX_", "_NX_");
+
+                //设置取值开始时间
+                String startString = startTimeString;
+                DateTime startDateTime = DateUtil.parse(startString);
+
+                //设置取值结束时间
+                String endDateString = endTimeString;
+                DateTime endDateTime0 = DateUtil.parse(endDateString);
+                DateTime endDateTime = DateUtil.endOfDay(endDateTime0);
+
+                //指定开始日期到结束日期的间隔
+                LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+                LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+                long between0 = ChronoUnit.MINUTES.between(day1, day2);
+                int between = (int) (between0 / 15);
+
+
+                for (int i = 0; i <= between; i++) {
+
+                    //开始时间00:00:01
+                    DateTime dateTime1 = DateUtil.offsetMinute(startDateTime, (i - 1) * 15);
+                    DateTime dateTime2 = DateUtil.offsetMinute(startDateTime, i * 15);
+                    BigDecimal bigDecimal1 = new BigDecimal(0);
+                    BigDecimal bigDecimal2 = new BigDecimal(0);
+                    BigDecimal rfdl = new BigDecimal(0);
+
+
+                    List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+
+                    if (historyRaw.size() > 0) {
+                        bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                        bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                        bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                        bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                        rfdl = bigDecimal2.subtract(bigDecimal1).multiply(meterPoint.getMagnification());
+
+                        if (rfdl.doubleValue() > 50000 || rfdl.doubleValue() < 0) {
+
+                            ArrayList<Double> arrayList = new ArrayList<>();
+                            for (PointData pointData : historyRaw) {
+                                arrayList.add(pointData.getValue());
+                            }
+                            int index = -1;
+                            // 定义增长阈值
+                            double threshold = 50000.0;
+
+                            for (int j = 1; j < arrayList.size(); j++) {
+                                double current = arrayList.get(j);
+                                double previous = arrayList.get(j - 1);
+                                double difference = current - previous;
+                                if (difference > threshold) {
+                                    index = j;
+                                    break;
+                                }
+                            }
+                            if (index != -1) {
+                                double valueGrow2 = arrayList.get(index);
+                                BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                                double valueGrow1 = arrayList.get(index - 1);
+                                BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                                rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1)).multiply(meterPoint.getMagnification());
+                            }
+                        }
+                    }
+
+
+                    tdLineFDL15MinMapper.insertLineFDL15Min(
+                            pointcode2,
+                            meterPoint.getWindpowerstationId(),
+                            meterPoint.getProjectId(),
+                            meterPoint.getDescription(),
+                            dateTime2.getTime(),
+                            bigDecimal2.doubleValue(),
+                            rfdl.doubleValue()
+                    );
+
+                }
+            }
+        }
+    }
+
+
+    /**
+     * 批量保存到taos(不会自动建表)
+     */
+    @Test
+    void saveSaveLineFDL15Min_batchInsert() {
+
+        //1,查询所有风电场
+        List<PowerStation> powerStationList = powerStationService.list(new QueryWrapper<PowerStation>()
+                .like("nem_code", "_FDC_"));
+
+        for (PowerStation powerStation : powerStationList) {
+            //2,根据场站ID,测点类型得到集电线路发电量的测点
+            List<MeterPoint> meterPointList = meterPointService.list(new QueryWrapper<MeterPoint>()
+                    .eq("windpowerstation_id", powerStation.getId())
+                    .eq("property", "CD")
+                    .eq("meter_type", "线路")
+                    .like("meter_class", "集电线路")
+            );
+
+            //3,遍历测点,拿到每个测点的nem_code
+            for (MeterPoint meterPoint : meterPointList) {
+                System.out.println(meterPoint);
+                //获取测点code
+                String pointcode = meterPoint.getNemCode();
+                String pointcode2 = pointcode.replace(".NX_", "_NX_");
+
+                //设置取值开始时间
+                String startString = startTimeString;
+                DateTime startDateTime = DateUtil.parse(startString);
+
+                //设置取值结束时间
+                String endDateString = endTimeString;
+                DateTime endDateTime0 = DateUtil.parse(endDateString);
+                DateTime endDateTime = DateUtil.endOfDay(endDateTime0);
+
+                //指定开始日期到结束日期的间隔
+                LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+                LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+                long between0 = ChronoUnit.MINUTES.between(day1, day2);
+                int between = (int) (between0 / 15);
+
+                ArrayList<TDLineFDL15Min> tdLineFDL15Mins = new ArrayList<>();
+
+
+                for (int i = 0; i <= between; i++) {
+
+                    //开始时间00:00:01
+                    DateTime dateTime1 = DateUtil.offsetMinute(startDateTime, (i - 1) * 15);
+                    DateTime dateTime2 = DateUtil.offsetMinute(startDateTime, i * 15);
+                    BigDecimal bigDecimal1 = new BigDecimal(0);
+                    BigDecimal bigDecimal2 = new BigDecimal(0);
+                    BigDecimal rfdl = new BigDecimal(0);
+
+
+                    List<PointData> historyRaw = adapter.getHistoryRaw(pointcode, dateTime1.getTime(), dateTime2.getTime());
+
+                    if (historyRaw.size() > 0) {
+                        bigDecimal1 = new BigDecimal(Double.toString(historyRaw.get(0).getValue()));
+                        bigDecimal1 = bigDecimal1.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                        bigDecimal2 = new BigDecimal(Double.toString(historyRaw.get(historyRaw.size() - 1).getValue()));
+                        bigDecimal2 = bigDecimal2.divide(meterPoint.getXs(), 4, RoundingMode.HALF_EVEN);
+                        rfdl = bigDecimal2.subtract(bigDecimal1).multiply(meterPoint.getMagnification());
+
+                        if (rfdl.doubleValue() > 50000 || rfdl.doubleValue() < 0) {
+
+                            ArrayList<Double> arrayList = new ArrayList<>();
+                            for (PointData pointData : historyRaw) {
+                                arrayList.add(pointData.getValue());
+                            }
+                            int index = -1;
+                            // 定义增长阈值
+                            double threshold = 50000.0;
+
+                            for (int j = 1; j < arrayList.size(); j++) {
+                                double current = arrayList.get(j);
+                                double previous = arrayList.get(j - 1);
+                                double difference = current - previous;
+                                if (difference > threshold) {
+                                    index = j;
+                                    break;
+                                }
+                            }
+                            if (index != -1) {
+                                double valueGrow2 = arrayList.get(index);
+                                BigDecimal bigDecimalGrow2 = new BigDecimal(Double.toString(valueGrow2));
+                                double valueGrow1 = arrayList.get(index - 1);
+                                BigDecimal bigDecimalGrow1 = new BigDecimal(Double.toString(valueGrow1));
+                                rfdl = (bigDecimal2.subtract(bigDecimalGrow2).add(bigDecimalGrow1).subtract(bigDecimal1)).multiply(meterPoint.getMagnification());
+                            }
+                        }
+                    }
+
+                    TDLineFDL15Min tdLineFDL15Min = new TDLineFDL15Min();
+                    tdLineFDL15Min.setTbName(pointcode2);
+                    tdLineFDL15Min.setTs(dateTime2.getTime());
+                    tdLineFDL15Min.setBottom(bigDecimal2.doubleValue());
+                    tdLineFDL15Min.setMeter(rfdl.doubleValue());
+                    tdLineFDL15Min.setPowerstation(meterPoint.getWindpowerstationId());
+                    tdLineFDL15Min.setProject(meterPoint.getProjectId());
+                    tdLineFDL15Min.setName(meterPoint.getDescription());
+
+                    tdLineFDL15Mins.add(tdLineFDL15Min);
+                }
+
+
+                List<List<TDLineFDL15Min>> split = ListUtil.split(tdLineFDL15Mins, 1000);
+                int count = 0;
+                for (List<TDLineFDL15Min> targets : split) {
+                    StringBuilder sb = new StringBuilder();
+                    for (TDLineFDL15Min target : targets) {
+                        sb.append(target.getTbName())
+                                .append(" values(")
+                                .append(target.getTs()).append(",").append(target.getBottom()).append(",").append(target.getMeter())
+                                .append(") ");
+                    }
+                    count += tdLineFDL15MinMapper.insert(sb.toString());
+                }
+
+
+            }
+        }
+    }
+
+
+
+
+
+
+    /*
+     * 日理论发电量(每台风机,综合到每个场站,每个期次,每条线路)
+     * 1分钟平均风速乘model_power_details的理论功率
+     * w=pt,理论功率乘时间(kw/h)除以60为1分钟理论发电量
+     * pro_basic_equipment表中获取到所有风机,每台风机型号等
+     * uniFormCode AI022 从testing_point中获取到所有风速测点
+     * 从适配器中取1分钟平均风速,根据风速从model_power_details中取到理论功率
+     * 计算1分钟理论发电量
+     * 保存到taos数据库中
+     */
+
+    @Resource
+    private EquipmentServiceImpl equipmentService;
+    @Resource
+    private ModelPowerDetailsServiceImpl modelPowerDetailsService;
+    @Resource
+    private TestingPointServiceImpl testingPointService;
+
+
+    @Test
+    public void llfdl_1Min_0() {
+
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime = DateUtil.parse(startString);
+
+        //设置取值结束时间
+        String endDateString = endTimeString;
+        DateTime endDateTime0 = DateUtil.parse(endDateString);
+        DateTime endDateTime = DateUtil.endOfDay(endDateTime0);
+
+        //指定开始日期到结束日期的间隔
+        LocalDateTime day1 = LocalDateTimeUtil.of(startDateTime);
+        LocalDateTime day2 = LocalDateTimeUtil.of(endDateTime);
+        long between0 = ChronoUnit.MINUTES.between(day1, day2);
+        int between = (int) (between0 / 15);
+
+
+        //从pro_basic_equipment(实体类为Equipment)表中获取到所有风机,每台风机型号等
+        List<Equipment> equipmentList = equipmentService.list(new QueryWrapper<Equipment>()
+                .eq("spare1", "WT")
+        );
+
+        //遍历equipmentList拿到每台风机的型号(model_id)
+        for (Equipment equipment : equipmentList) {
+            String modelId = equipment.getModelId();
+            //根据model_id从model_power_details表中获取到理论功率
+            List<ModelPowerDetails> modelPowerDetailsList = modelPowerDetailsService.list(new QueryWrapper<ModelPowerDetails>()
+                    .eq("model_id", modelId)
+            );
+//            System.out.println(modelPowerDetailsList);
+
+            //遍历modelPowerDetailsList,取出风速speed和理论功率theory_power放入map集合中,键为speed,值为theory_power
+            Map<BigDecimal, Double> map = new HashMap<>();
+            for (ModelPowerDetails modelPowerDetails : modelPowerDetailsList) {
+                Double speed0 = modelPowerDetails.getSpeed();
+                BigDecimal speed = new BigDecimal(speed0).setScale(2, RoundingMode.HALF_EVEN);
+                Double theoryPower = modelPowerDetails.getTheoryPower();
+                map.put(speed, theoryPower);
+            }
+
+            //根据每台风机的编码和uniform_code=AI022从testing_point表中获取到每台风机的风速测点
+            List<TestingPoint> testingPointList = testingPointService.list(new QueryWrapper<TestingPoint>()
+                    .eq("thing_id", equipment.getNemCode())
+                    .eq("uniform_code", "AI022")
+            );
+            //遍历testingPointList拿到每台风机的风速测点
+            for (TestingPoint testingPoint : testingPointList) {
+                String pointcode = testingPoint.getCode();
+                //适配器获取到1分钟平均风速
+                List<PointData> pointDataList = adapter.getHistorySnap(pointcode, startDateTime.getTime(), endDateTime.getTime(), 60);
+                //遍历pointDataList拿到每台风机的1分钟平均风速,根据风速从map集合中取到理论功率,计算1分钟理论发电量
+                for (PointData pointData : pointDataList) {
+                    //风速
+                    double speed0 = pointData.getValue();
+                    BigDecimal speed = new BigDecimal(speed0).setScale(2, RoundingMode.HALF_EVEN);
+
+                    Double theoryPower = 0.0;
+                    if (speed0 >= 3) {
+                        //理论功率
+                        theoryPower = map.get(speed);
+                    }
+                    //时间
+                    DateTime dateTime = DateTime.of(pointData.getTs());
+                    //1分钟理论发电量
+                    BigDecimal llfdl = new BigDecimal(Double.toString(theoryPower))
+                            .multiply(new BigDecimal(Double.toString(1)))
+                            .divide(new BigDecimal(Double.toString(60)), 2, RoundingMode.HALF_UP);
+
+                    //输出
+                    System.out.println("风机编码:" + equipment.getNemCode() + "风速测点:" + pointcode + "时间:" + dateTime + "1分钟理论发电量:" + llfdl);
+
+                }
+            }
+
+
+        }
+
+
+    }
+
+    //优化查询
+    @Test
+    public void llfdl_1Min_1() {
+
+        //设置取值开始时间
+        String startString = startTimeString;
+        DateTime startDateTime = DateUtil.parse(startString);
+
+        //设置取值结束时间
+        String endDateString = endTimeString;
+        DateTime endDateTime0 = DateUtil.parse(endDateString);
+        DateTime endDateTime = DateUtil.endOfDay(endDateTime0);
+
+        //从pro_basic_equipment(实体类为Equipment)表中获取到所有风机,每台风机型号等
+        List<Equipment> equipmentList = equipmentService.list(new QueryWrapper<Equipment>()
+                .eq("spare1", "WT")
+        );
+
+        //model_power_details表中获取到所有型号各风速对应的理论功率
+        List<ModelPowerDetails> modelPowerDetailsList = modelPowerDetailsService.list();
+
+        //遍历modelPowerDetailsList,放入map集合中,键为model_id,值为map集合,值的map集合的键为speed,值为theory_power
+        Map<String, Map<BigDecimal, Double>> map = new HashMap<>();
+        for (ModelPowerDetails modelPowerDetails : modelPowerDetailsList) {
+            String modelId = modelPowerDetails.getModelId();
+            Double speed0 = modelPowerDetails.getSpeed();
+            BigDecimal speed = new BigDecimal(speed0).setScale(2, RoundingMode.HALF_EVEN);
+            Double theoryPower = modelPowerDetails.getTheoryPower();
+
+            // 检查是否已存在该modelId的映射关系
+            if (map.containsKey(modelId)) {
+                // 如果已存在，获取对应的内层HashMap，并添加新的映射关系
+                Map<BigDecimal, Double> innerMap = map.get(modelId);
+                innerMap.put(speed, theoryPower);
+            } else {
+                // 如果不存在，创建新的内层HashMap，并添加映射关系
+                Map<BigDecimal, Double> innerMap = new HashMap<>();
+                innerMap.put(speed, theoryPower);
+                map.put(modelId, innerMap);
+            }
+        }
+
+        //根据uniform_code=AI022从testing_point表中获取到风机的风速测点
+        List<TestingPoint> testingPointList = testingPointService.list(new QueryWrapper<TestingPoint>()
+                .eq("uniform_code", "AI022")
+        );
+        //遍历testingPointList,把code取出放入一个string集合
+        List<String> codeList = new ArrayList<>();
+        for (TestingPoint testingPoint : testingPointList) {
+            String code = testingPoint.getCode();
+            codeList.add(code);
+        }
+
+        //新建一个map,键为风机编码,值为map集合,值的map集合的键为时间,值为1分钟理论发电量
+        Map<String, Map<Long, BigDecimal>> map1 = new HashMap<>();
+
+        //遍历codeList作为适配器的参数,获取到1分钟平均风速
+        for (String code : codeList) {
+            List<PointData> pointDataList = adapter.getHistorySnap(code, startDateTime.getTime(), endDateTime.getTime(), 60);
+
+            //遍历testingPointList,根据code取到风机编码thing_id
+            for (TestingPoint testingPoint : testingPointList) {
+                String code1 = testingPoint.getCode();
+                if (code.equals(code1)) {
+                    String thingId = testingPoint.getThingId();
+                    //根据thingId从equipmentList中取出型号
+                    for (Equipment equipment : equipmentList) {
+                        String nemCode = equipment.getNemCode();
+                        if (thingId.equals(nemCode)) {
+                            String modelId = equipment.getModelId();
+                            //根据modelId从map中取出map集合,键为speed,值为theory_power
+                            Map<BigDecimal, Double> map2 = map.get(modelId);
+                            //遍历pointDataList,拿到风速,根据风速从map2中取到理论功率,计算1分钟理论发电量
+                            for (PointData pointData : pointDataList) {
+                                //风速
+                                double speed0 = pointData.getValue();
+                                BigDecimal speed = new BigDecimal(speed0).setScale(2, RoundingMode.HALF_EVEN);
+
+                                Double theoryPower = 0.0;
+                                if (speed0 >= 3) {
+                                    //理论功率
+                                    theoryPower = map2.get(speed);
+                                }
+                                //时间
+                                DateTime dateTime = DateTime.of(pointData.getTs());
+                                //1分钟理论发电量
+                                BigDecimal llfdl = new BigDecimal(Double.toString(theoryPower))
+                                        .multiply(new BigDecimal(Double.toString(1)))
+                                        .divide(new BigDecimal(Double.toString(60)), 2, RoundingMode.HALF_UP);
+
+                                //存入map1,键为风机编码,值为map集合,值的map集合的键为时间,值为1分钟理论发电量
+                                if (map1.containsKey(nemCode)) {
+                                    // 如果已存在，获取对应的内层HashMap，并添加新的映射关系
+                                    Map<Long, BigDecimal> innerMap = map1.get(nemCode);
+                                    innerMap.put(dateTime.getTime(), llfdl);
+                                } else {
+                                    // 如果不存在，创建新的内层HashMap，并添加映射关系
+                                    Map<Long, BigDecimal> innerMap = new HashMap<>();
+                                    innerMap.put(dateTime.getTime(), llfdl);
+                                    map1.put(nemCode, innerMap);
+                                }
+
+                            }
+
+
+                        }
+                    }
+                }
+
+
+            }
+        }
+    }
+}
+
+
+
+
+
+
+
+
+

electricity/meter/src/main/java/com/gyee/gaia/meter/service/saveTDengine/TDSaveLineFDL15MinTest.java

@@ -288,6 +288,8 @@ class TDSaveLineFDL15MinTest {
     }
 
 
+
+
 }
 
 

electricity/meter/src/main/resources/application.yml

@@ -1,106 +0,0 @@
-#server:
-#  port: 8022
-#
-#start:
-#  time: 2023-06-02
-#
-#end:
-#  time: 2023-06-08
-#test:
-#  abcd: asdf
-#adapter:
-#  url: http://192.168.1.67:8011/ts
-#
-#
-#meter:
-#  stations: MHS_FDC,NSS_FDC
-#
-#spring:
-#  cache:
-#    type: SIMPLE
-#  datasource:
-#    dynamic:
-#      primary: master #设置默认的数据源或者数据源组,默认值即为master
-#      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
-#      datasource:
-#        master:
-#          url: jdbc:postgresql://192.168.10.18:5432/nx_dev
-#          username: gdprod
-#          password: gyee123
-#          driver-class-name: org.postgresql.Driver
-#          type: com.alibaba.druid.pool.DruidDataSource
-#        meter:
-#          url: jdbc:TAOS-RS://192.168.1.67:6041/meter?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8
-#          username: root
-#          password: taosdata
-#          driver-class-name: com.taosdata.jdbc.rs.RestfulDriver
-#    # datasource:
-#    #   driver-class-name: org.postgresql.Driver
-#    #   url: jdbc:postgresql://192.168.10.18:5432/nx_dev
-#    #   username: gdprod
-#    #   password: gyee123
-#    #   # url: jdbc:postgresql://192.168.1.67:5432/gyee
-#    #   # username: gyee
-#    #   # password: Gyee@2023!@#
-#    #   type: com.alibaba.druid.pool.DruidDataSource
-#    druid:
-#      max-active: 20
-#      initial-size: 1
-#      min-idle: 3
-#      max-wait: 60000
-#      time-between-eviction-runs-millis: 60000
-#      min-evictable-idle-time-millis: 300000
-#      test-while-idle: true
-#      test-on-borrow: false
-#      test-on-return: false
-#  jackson:
-#    date-format: yyyy-MM-dd HH:mm:ss
-#    time-zone: GMT+8
-#    default-property-inclusion: always
-#
-#
-#mybatis-plus:
-#  typeAliasesPackage: com.gyee.gaia.meter.entity
-#  mapper-locations: classpath:mappers-postgresql/*.xml
-#  global-config:
-#    #主键类型  0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
-#    id-type: 3
-#    #字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
-#    field-strategy: 2
-#    #驼峰下划线转换
-#    db-column-underline: true
-#    #mp2.3+ 全局表前缀 mp_
-#    #table-prefix: mp_
-#    #刷新mapper 调试神器
-#    #refresh-mapper: true
-#    #数据库大写下划线转换
-#    #capital-mode: true
-#    # Sequence序列接口实现类配置
-#    key-generator: com.baomidou.mybatisplus.incrementer.OracleKeyGenerator
-#    #逻辑删除配置（下面3个配置）
-#    logic-delete-value: 1
-#    logic-not-delete-value: 0
-#    #sql-injector: com.baomidou.mybatisplus.mapper.LogicSqlInjector
-#    #自定义填充策略接口实现
-#    #meta-object-handler: com.baomidou.springboot.MyMetaObjectHandler
-#  configuration:
-#    #配置返回数据库(column下划线命名&&返回java实体是驼峰命名)，自动匹配无需as（没开启这个，SQL需要写as： select user_id as userId）
-#    map-underscore-to-camel-case: true
-#    cache-enabled: false
-#    #配置JdbcTypeForNull, oracle数据库必须配置
-#    jdbc-type-for-null: 'null'
-#    callSettersOnNulls: true
-#
-#xxl:
-#  job:
-#    admin:
-#      addresses: http://192.168.10.18:8080/xxl-job-admin
-#    accessToken:
-#    executor:
-#      appname: meter
-#      address:
-#      ip:
-#      port: 9999
-#      logpath: c:/xxl-job/meter/logs
-#      logretentiondays: 30
-#

electricity/meter/src/main/resources/bootstrap.yaml

@@ -3,7 +3,8 @@ spring:
     name: meter
   profiles:
     # 环境配置
-    active: dev
+    active: prod
+
   cloud:
     nacos:
       discovery:
@@ -16,9 +17,9 @@ spring:
         # 配置文件格式
         file-extension: yml
         #开发环境配置命名空间
-        namespace: fe339fbd-7113-405f-8d2a-70659c5d53e4
+#        namespace: fe339fbd-7113-405f-8d2a-70659c5d53e4
         #生产环境配置命名空间
-#        namespace: d148acca-95e7-4e07-a566-9a69012bcf01
+        namespace: d148acca-95e7-4e07-a566-9a69012bcf01
         group: meter
         refresh-enabled: true
         # 共享配置

electricity/meter/src/main/resources/mappers-postgresql/ModelPowerDetailsMapper.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.gyee.gaia.meter.mapper.ModelPowerDetailsMapper">
+
+
+</mapper>

electricity/wind/src/main/java/com/gyee/gaia/WindPowergenApp.java

@@ -1,7 +1,9 @@
 package com.gyee.gaia;
 
+import com.gyee.gaia.electricity.wind.config.AppConfig;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 import org.springframework.cloud.openfeign.EnableFeignClients;
 
@@ -9,6 +11,7 @@ import org.springframework.cloud.openfeign.EnableFeignClients;
 @SpringBootApplication
 @EnableDiscoveryClient
 @EnableFeignClients
+@EnableConfigurationProperties
 public class WindPowergenApp {
 
     public static void main(String[] args) {

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/job/CalcEquipPowerGenDay.java

@@ -293,8 +293,10 @@ public class CalcEquipPowerGenDay {
 
         //查询1分钟平均风速
         QueryWrapper<RealtimeAverageTarget> ratWrapper = new QueryWrapper<>();
-        ratWrapper.select("AVG(wind_speed) wind_speed", "SUM(theory_generation) theory_generation", "equipment_id").eq("uniform_code", "1FZPJZB")
-                .between("time", time1.getTime(), time2.getTime()).groupBy("equipment_id");//.orderByAsc("time");
+        ratWrapper.select("AVG(wind_speed) wind_speed", "SUM(theory_generation) theory_generation", "equipment_id")
+                .eq("uniform_code", "1FZPJZB")
+                .between("time", time1.getTime(), time2.getTime())
+                .groupBy("equipment_id");//.orderByAsc("time");
         List<RealtimeAverageTarget> ratList = realtimeAverageTargetService.list(ratWrapper);
         Map<String, RealtimeAverageTarget> sratMap = ratList.stream().collect(Collectors.toMap(RealtimeAverageTarget::getEquipmentId, Function.identity()));
         //Map<String, List<RealtimeAverageTarget>> ratsListMap = ratList.stream().collect(Collectors.groupingBy(RealtimeAverageTarget::getEquipmentId));

electricity/wind/src/main/java/com/gyee/gaia/electricity/wind/serviceimpl/EquipPowerGenDayServiceImpl.java

@@ -86,6 +86,7 @@ public class EquipPowerGenDayServiceImpl extends ServiceImpl<EquipPowerGenDayMap
             list = list.stream().peek(d -> d.setUniformCode(CacheContext.splssMap.get(d.getFacilityId()))).sorted(Comparator.comparing(EquipPowerGenDay::getFacilityId)).collect(Collectors.toList());
             list.add(powerGenDay);
         }
+        list=list.stream().peek(l->l.setCategory(String.valueOf(l.getTheoryGeneration().divide(l.getGeneratingCapacity(),2, RoundingMode.HALF_EVEN)))).collect(Collectors.toList());
         return list;
     }
 }

realtime/wind/src/main/java/com/gyee/gaia/realtime/wind/job/CauseJobHandler.java

@@ -160,4 +160,5 @@ public class CauseJobHandler implements ApplicationRunner {
         }
 
     }
+
 }