修改可开放容量路径限额

jinyun/availCap/src/main/java/com/jinyun/cap/AvailCapMain.java

@@ -202,7 +202,21 @@ public class AvailCapMain {
                     }
                 } else if (loadType == 3) {
                     load[0] = pvAvg;
-                    for (int i = 1; i < 96; i++) {
+                    for (int i = 1; i < 32; i++) {
+                        double r = 0.08 * (Math.random() - 0.5) * loadCap;
+                        load[i] = load[i - 1] + r;
+                        load[i] = Math.min(load[i], loadCap);
+                        load[i] = Math.max(load[i], minLoad);
+                    }
+                    load[32] = pvAvg;
+                    for (int i = 33; i < 88; i++) {
+                        double r = 0.05 * (Math.random() - 0.5) * loadCap;
+                        load[i] = load[i - 1] + r;
+                        load[i] = Math.min(load[i], loadCap);
+                        load[i] = Math.max(load[i], minLoad);
+                    }
+                    load[88] = pvAvg;
+                    for (int i = 89; i < 96; i++) {
                         double r = 0.1 * (Math.random() - 0.5) * loadCap;
                         load[i] = load[i - 1] + r;
                         load[i] = Math.min(load[i], loadCap);
@@ -502,12 +516,9 @@ public class AvailCapMain {
                 for (int i = 0; i < 96; i++) {
                     lineRatedICv[i] = lineRatedI;
                 }
-                double[] seasonCluster2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonClusterTable, args[3], 2, 96);
-                double[] seasonMax2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], 2, 96);
-                double[] cap1 = sqliteDb.queryAvailCap(args[2] + availCapTableName, args[3], 1, 96);
-                double[] cap2 = sqliteDb.queryAvailCap(args[2] + availCapTableName, args[3], 2, 96);
-                double[] cap3 = sqliteDb.queryAvailCap(args[2] + availCapTableName, args[3], 3, 96);
-                double[] cap4 = sqliteDb.queryAvailCap(args[2] + availCapTableName, args[3], 4, 96);
+                double[] seasonCluster2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonClusterTable, args[3], 3, 96);
+                double[] seasonMax2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], 3, 96);
+                double[] cap2 = sqliteDb.queryAvailCap(args[2] + availCapTableName, args[3], 3, 96);
 //                System.out.println("时段,1,2,3,4");
 //                for (int i = 0; i < 24; i++) {
 //                    System.out.println(i + "," + cap1[4 * i] + "," + cap2[4 * i] + "," + cap3[4 * i] + "," + cap4[4 * i]);

jinyun/availCap/src/main/java/com/jinyun/cap/AvailCapModel.java

@@ -626,14 +626,19 @@ public class AvailCapModel {
                 noPush = false;
                 double[][] availCap = edgeAvailCap.get(e);
                 for (Edge edge : edgeStack) {
+                    if (!ps.getResource(edge.getEquips().getFirst()).getType().toUpperCase().equals("BREAKER"))
+                        continue;
                     double[][] pathAvailCap = edgeAvailCap.get(edge);
                     for (int season = 0; season < 4; season++) {
                         for (int j = 0; j < pointNum; j++) {
                             if (availCap[season][j] > pathAvailCap[season][j]) {
                                 availCap[season][j] = pathAvailCap[season][j];
-//                                if (availCap[season][j] < 0) {
-//                                    availCap[season][j] = 0;
-//                                }
+                                if (availCap[season][j] < 0) {
+                                    if (j > 0)
+                                        availCap[season][j] = availCap[season][j - 1];
+                                    else
+                                        availCap[season][j] = 0;
+                                }
                             }
                         }
                     }
@@ -1067,12 +1072,121 @@ public class AvailCapModel {
                     }
                 }
             }
+//            if (e.getEquips().getFirst().equals("PD_11100000_10612548")) {
+//                for (int i = 0; i < pointNum; i++) {
+//                    System.out.println(availCap[0][i] + "," + availCap[1][i] + "," + availCap[2][i] + "," + availCap[3][i]);
+//                }
+//            }
             edgeAvailCap.put(e, availCap);
         }
 //        }
     }
 
     /**
+     * 查询主线电流和参数
+     * @param lineISeasontableName 线路电流按季度分析结果表名
+     * @param swISeasontableName 开关电流按季度分析结果表名
+     * @param dbFile 数据库名
+     */
+    public void mainLineI(String lineISeasontableName, String swISeasontableName, String dbFile) {
+        SqliteDb sqliteDb = new SqliteDb(dbFile);
+        // 查询主线电流数据
+        double[][] mainLineI = new double[4][pointNum];
+        for (int season = 1; season < 5; season++) {
+            int pNTimes = 3;
+            double[] I = sqliteDb.querySeasonLineI(lineISeasontableName, season, pNTimes * pointNum);
+            for (int i = 0; i < pointNum; i++) {
+                mainLineI[season - 1][i] = I[pNTimes * i];
+                if (mainLineI[season - 1][i] < I[pNTimes * i + 1]) {
+                    mainLineI[season - 1][i] = I[pNTimes * i + 1];
+                }
+                if (mainLineI[season - 1][i] < I[pNTimes * i + 2]) {
+                    mainLineI[season - 1][i] = I[pNTimes * i + 2];
+                }
+            }
+        }
+        // 主线电流裕度，按第一条有额定电流的线路算
+        String supplyCn = ps.getSourceCns().get(0);
+        UndirectedGraph<String, Edge> g = ps.getActiveIslands().get(0);
+        Edge mainLine = g.edgesOf(supplyCn).iterator().next();
+        // 初始化节点为未访问状态
+        HashMap<String, Boolean> visited = new HashMap<>(g.vertexSet().size());
+        for (String cn : g.vertexSet()) {
+            visited.put(cn, false);
+        }
+        //用于深度优先搜索的栈
+        Deque<String> stack = new ArrayDeque<>();
+        Deque<Edge> edgeStack = new ArrayDeque<>();
+        stack.push(supplyCn);   // 将电源节点压入栈内
+        while (!stack.isEmpty()) {
+            boolean noPush = true;
+            String cn = stack.peek();
+            for (Edge e: g.edgesOf(cn)) {
+                if (!edgeStack.isEmpty() && edgeStack.peek().equals(e))
+                    continue;
+                if (e.getLimI() < 10000) {
+                    mainLine = e;
+                    stack.clear();
+                    break;
+                }
+                String neighbor = g.getEdgeTarget(e);
+                if (neighbor.equals(cn))
+                    neighbor = g.getEdgeSource(e);
+                // 如果顶点已经被遍历过，则不进行处理
+                if (visited.get(neighbor))
+                    continue;
+                // 未遍历过的节点
+                stack.push(neighbor);
+                noPush = false;
+                edgeStack.push(e);
+                break;
+            }
+            if (noPush) {
+                if (!stack.isEmpty()) {
+                    visited.put(stack.pop(), true);
+                }
+                if (!edgeStack.isEmpty()) {
+                    edgeStack.pop();
+                }
+            }
+        }
+        double mainLineLimI = mainLine.getLimI();
+        double mainLineType = mainLine.getType();
+        double[][] mainLineAvailCap = new double[4][pointNum];
+        for (int season = 0; season < 4; season++) {
+            for (int j = 0; j < pointNum; j++) {
+                if (season == 1 || season == 2) {
+                    if (mainLineType == 1) {
+                        mainLineAvailCap[season][j] = mainLineLimI * JKsm - mainLineI[season][j];
+                    } else if (mainLineType == 2) {
+                        mainLineAvailCap[season][j] = mainLineLimI * LGJsm - mainLineI[season][j];
+                    }
+                } else {
+                    if (mainLineType == 1) {
+                        mainLineAvailCap[season][j] = mainLineLimI * JKwin - mainLineI[season][j];
+                    } else if (mainLineType == 2) {
+                        mainLineAvailCap[season][j] = mainLineLimI * LGJwin - mainLineI[season][j];
+                    }
+                }
+            }
+        }
+        System.out.println("夏季额定电流,夏季最大电流,夏季可开放容量,夏季差值,冬季额定电流,冬季最大电流,冬季可开放容量,冬季差值");
+        for (int i = 0; i < pointNum; i++) {
+            if (mainLineType == 1) {
+                System.out.println(mainLineLimI * JKsm + "," + mainLineI[1][i] + "," + mainLineAvailCap[1][i] + "," +
+                        (mainLineLimI * JKsm - mainLineI[1][i] - mainLineAvailCap[1][i]) + "," + mainLineLimI * JKwin + "," +
+                        mainLineI[3][i] + "," + mainLineAvailCap[3][i] + "," +
+                        (mainLineLimI * JKwin - mainLineI[3][i] - mainLineAvailCap[3][i]));
+            } else if (mainLineType == 2) {
+                System.out.println(mainLineLimI * LGJsm + "," + mainLineI[1][i] + "," + mainLineAvailCap[1][i] + "," +
+                        (mainLineLimI * LGJsm - mainLineI[1][i] - mainLineAvailCap[1][i]) + "," + mainLineLimI * LGJwin + "," +
+                        mainLineI[3][i] + "," + mainLineAvailCap[3][i] + "," +
+                        (mainLineLimI * LGJwin - mainLineI[3][i] - mainLineAvailCap[3][i]));
+            }
+        }
+    }
+
+    /**
      * 设备预警分析
      */
     public void warnDevAnalysis(String dbFile, String substationTable, String tfWarnTable, String tfTable, String tfParamTable, String tfSeasonTable,

jinyun/availCap/src/main/kotlin/com/jinyun/cap/PowerSystem.kt

@@ -13,7 +13,7 @@ import java.util.*
 import javax.xml.parsers.SAXParserFactory
 
 class TN(var id : String = "", val cns : LinkedList<String> = LinkedList())
-class Edge(val equips : LinkedList<String> = LinkedList(), var limI : Double = 1000.0, var type : Int = 1)
+class Edge(val equips : LinkedList<String> = LinkedList(), var limI : Double = 867.0, var type : Int = 1)
 
 /**
  * 该类用于管理电网资源(MapObject)的方法