Skip to content

S
sparrowzz
Commit da172559 by xuchengsi
Options

可开放容量分析算法

parent ebc12709
正在显示 包含 7024 行增加 和 0 行删除
availCap/build.gradle 0 → 100644
apply plugin: 'idea'
apply plugin: 'kotlin'
apply plugin: 'application'
mainClassName = 'AvailCapMain'
buildscript {
ext.kotlin_version = '1.1.51'
repositories {
mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
repositories {
mavenCentral()
}
dependencies {
compile('cn.zju:alg:2.1.1-rc32') {
transitive = false
}
compile "org.jgrapht:jgrapht-core:1.0.0"
compile "org.xerial:sqlite-jdbc:3.8.11.2"
// https://mvnrepository.com/artifact/com.alibaba/fastjson
compile "com.alibaba:fastjson:1.2.54"
compile group: 'org.apache.logging.log4j', name: 'log4j-core', version: '2.11.0'
compile group: 'org.apache.logging.log4j', name: 'log4j-api', version: '2.11.0'
testCompile group: 'junit', name: 'junit', version: '4.12'
compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
// compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
// testCompile group: 'junit', name: 'junit', version: '4.12'
}
compileKotlin {
kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
kotlinOptions.jvmTarget = "1.8"
}
jar {
from {
//添加依懒到打包文件
//configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
configurations.runtime.collect{zipTree(it)}
}
manifest {
attributes 'Main-Class': mainClassName
}
}
availCap/src/main/java/AvailCapMain.java 0 → 100644
//package availCap;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.LinkedList;
import java.util.List;
public class AvailCapMain {
static String allFeederNameTable = "所有馈线名称";
static String allPsWarnTable = "所有馈线预警设备";
static String allPsLineWarnTable = "所有馈线线路预警设备";
static String allPsTfWarnTable = "所有馈线公变预警设备";
static String maxMinAvailCapTable = "最大最小可开放容量线路";
static String lineITableName = "电流";
static String switchTableName = "开关";
static String lineParamTableName = "参数";
static String oneLineParamTableName = "单线参数";
static String transformerTableName = "公变";
static String tfParamTableName = "公变参数";
static String availCapTableName = "可接入容量";
static String swToLineTableName = "开关线路对应";
static String swToTfTableName = "开关公变对应";
static String tfToLineTableName = "公变线路对应";
static String lineWarnTableName = "线路预警";
static String tfWarnTableName = "公变预警";
static String substationTableName = "变电站";
static String tfMonthUbTableName = "公变月不平衡度";
static String linePassRateTableName = "线路合格率";
static String tfOverLoadRateTableName = "公变越限率";
static String feederTableName = "馈线名称";
static String loadPosTable = "负荷接入位置";
public static void main(String[] args) {
// args[0]选择调用的方法
switch (args[0]) {
case "parseData":
// parseData为解析数据文件和存库操作，args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为线路电流历史数据文件夹的路径
// args[4]为开关历史数据文件夹的路径，args[5]为线路参数.csv格式文件数据，args[6]为公变历史数据文件夹的路径，
// args[7]为公变参数文件的路径，args[8]为存储所有馈线数据的数据库文件的路径，args[9]为变电站名称
HistoryData.createLineCurrentTable(args[1] + "\\" + args[2] + ".db", args[2] + lineITableName);
HistoryData.parseLineCurrent(args[2] + lineITableName, args[3], args[1] + "\\" + args[2] + ".db");
HistoryData.createSwitchTable(args[1] + "\\" + args[2] + ".db", args[2] + switchTableName);
HistoryData.parseSwitch(args[2] + switchTableName, args[4], args[1] + "\\" + args[2] + ".db");
HistoryData.createLineParamTable(args[1] + "\\" + args[2] + ".db", args[2] + lineParamTableName);
HistoryData.parseLineParam(args[2] + lineParamTableName, args[5], args[1] + "\\" + args[2] + ".db");
HistoryData.createTFTable(args[1] + "\\" + args[2] + ".db", args[2] + transformerTableName);
HistoryData.parseTF(args[2] + transformerTableName, args[6], args[1] + "\\" + args[2] + ".db");
HistoryData.createTFParamTable(args[1] + "\\" + args[2] + ".db", args[2] + tfParamTableName);
HistoryData.parseTFParam(args[2] + tfParamTableName, args[7], args[1] + "\\" + args[2] + ".db");
HistoryData.parseTFMRID(args[2] + tfParamTableName,
args[2] + transformerTableName, args[1] + "\\" + args[2] + ".db");
HistoryData historyData = new HistoryData();
// 历史数据处理
historyData.lineCurrentDataAnalysis(args[2] + lineITableName, args[1] + "\\" + args[2] + ".db");
historyData.switchDataAnalysis(args[2] + switchTableName, args[1] + "\\" + args[2] + ".db");
historyData.switchDataSeasonCluster(args[2] + switchTableName, args[1] + "\\" + args[2] + ".db");
historyData.switchDataPsCluster(args[2] + switchTableName, args[1] + "\\" + args[2] + ".db");
historyData.tfDataAnalysis(args[2] + transformerTableName, args[1] + "\\" + args[2] + ".db");
historyData.tfDataSeasonCluster(args[2] + transformerTableName, args[1] + "\\" + args[2] + ".db");
historyData.tfDataPsCluster(args[2] + transformerTableName, args[1] + "\\" + args[2] + ".db");
historyData.tfAvailCap(args[2] + transformerTableName + HistoryData.seasonTable,
args[2] + tfParamTableName, args[2] + transformerTableName, args[1] + "\\" + args[2] + ".db");
// 存储馈线名称
historyData.createFeederNameTable(args[1] + "\\" + args[2] + ".db", args[2] + feederTableName);
historyData.saveFeederName(args[2] + feederTableName, args[1] + "\\" + args[2] + ".db", args[2]);
// 存储所有馈线名称
AvailCapModel availCapModel = new AvailCapModel();
availCapModel.createAllFeederNameTable(args[8], allFeederNameTable);
availCapModel.saveAllFeederNameTable(args[8], allFeederNameTable, args[2]);
// 存储变电站名称
availCapModel.createSubStationNameTable(args[1] + "\\" + args[2] + ".db", args[2] + substationTableName);
availCapModel.saveSubstationName(args[2] + substationTableName,
args[1] + "\\" + args[2] + ".db", args[9]);
break;
case "calAvailCap": {
// calAvailCap为计算可接入容量操作，args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为.xml文件的路径
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
String[] sourceStationNames = new String[]{sqliteDb.querySubstationName(args[2] + substationTableName)};
JyPowerSystem ps = new JyPowerSystem(sourceStationNames);
try {
ps.loadFromCimXML(new FileInputStream(new File(args[3])));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
ps.createActiveIslands();
availCapModel = new AvailCapModel(ps);
availCapModel.buildPaths();
// availCapModel.setEdgeLimI(args[2] + lineParamTableName, args[1] + "\\" + args[2] + ".db");
// 设置单线限额并存库
availCapModel.createOneLineParamTable(args[1] + "\\" + args[2] + ".db", args[2] + oneLineParamTableName);
availCapModel.setEdgeLimI(args[2] + lineParamTableName,
args[1] + "\\" + args[2] + ".db", args[2] + oneLineParamTableName);
availCapModel.setEdgeAvailCap(args[2] + lineITableName + HistoryData.seasonTable,
args[2] + switchTableName + HistoryData.seasonTable, args[1] + "\\" + args[2] + ".db");
availCapModel.createAvailCapTable(args[1] + "\\" + args[2] + ".db", args[2] + availCapTableName);
availCapModel.calAvailCap(args[2] + availCapTableName,
args[2] + switchTableName, args[1] + "\\" + args[2] + ".db");
break;
}
case "warnDev": {
// warnDev为设备预警分析。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为.xml文件的路径
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
String[] sourceStationNames = new String[]{sqliteDb.querySubstationName(args[2] + substationTableName)};
JyPowerSystem ps = new JyPowerSystem(sourceStationNames);
try {
ps.loadFromCimXML(new FileInputStream(new File(args[3])));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
ps.createActiveIslands();
availCapModel = new AvailCapModel(ps);
availCapModel.buildPaths();
availCapModel.createSwToLineTable(args[1] + "\\" + args[2] + ".db", args[2] + swToLineTableName);
availCapModel.createSwToTfTable(args[1] + "\\" + args[2] + ".db", args[2] + swToTfTableName);
availCapModel.createTfToLineTable(args[1] + "\\" + args[2] + ".db", args[2] + tfToLineTableName);
availCapModel.createLineWarnTable(args[1] + "\\" + args[2] + ".db", args[2] + lineWarnTableName);
availCapModel.createTfWarnTable(args[1] + "\\" + args[2] + ".db", args[2] + tfWarnTableName);
availCapModel.switchToLine(args[2] + switchTableName,
args[1] + "\\" + args[2] + ".db", args[2] + swToLineTableName);
availCapModel.switchToTf(args[2] + switchTableName, args[1] + "\\" + args[2] + ".db",
args[2] + swToTfTableName, args[2] + tfToLineTableName);
availCapModel.warnDevAnalysis(args[1] + "\\" + args[2] + ".db", args[2] + substationTableName,
args[2] + tfWarnTableName, args[2] + transformerTableName,
args[2] + tfParamTableName, args[2] + transformerTableName + HistoryData.seasonTable,
args[2] + tfToLineTableName, args[2] + switchTableName,args[2] + swToLineTableName,
args[2] + oneLineParamTableName, args[2] + switchTableName + HistoryData.seasonTable,
args[2] + lineWarnTableName);
// List<WarnTf> warnTfs = sqliteDb.queryWarnTf(args[2] + tfWarnTableName);
// List<WarnLine> warnLines = sqliteDb.queryWarnLine(args[2] + lineWarnTableName);
// System.out.println(warnTfs.size() + ", " + warnLines.size());
break;
}
case "loadPos": {
// loadPos为分析负荷接入位置，args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为.xml文件的路径
// args[4]为负荷数据，4个数据用,分隔，args[5]为存储所有馈线数据的数据库文件的路径
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
String[] sourceStationNames = new String[]{sqliteDb.querySubstationName(args[2] + substationTableName)};
JyPowerSystem ps = new JyPowerSystem(sourceStationNames);
try {
ps.loadFromCimXML(new FileInputStream(new File(args[3])));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
ps.createActiveIslands();
availCapModel = new AvailCapModel(ps);
availCapModel.buildPaths();
availCapModel.createLoadPosTable(args[5], loadPosTable);
String[] loadStr = args[4].split(",");
double[] loadFt = new double[4];
for (int i = 0; i < 4; i++) {
loadFt[i] = Double.parseDouble(loadStr[i]);
}
// 生成负荷数据
double[] load = new double[96];
for (int i = 0; i < 32; i++) {
load[i] = loadFt[2];
}
for (int i = 32; i < 88; i++) {
load[i] = loadFt[1];
}
for (int i = 88; i < 96; i++) {
load[i] = loadFt[2];
}
LoadPos loadPos = availCapModel.loadPosOpt(load, args[2] + switchTableName,
args[2] + availCapTableName, args[1] + "\\" + args[2] + ".db",
args[2] + substationTableName, args[2] + feederTableName,
args[2] + oneLineParamTableName, args[2] + switchTableName + HistoryData.seasonClusterTable,
args[2] + swToTfTableName, args[2] + tfParamTableName,
args[2] + transformerTableName + HistoryData.tfAvailCapTable,
args[2] + transformerTableName + HistoryData.seasonClusterTable,
args[2] + transformerTableName + HistoryData.minITable, args[5], loadPosTable);
break;
}
case "mouseOverSw": {
// mouseOverSw为鼠标放置在开关上，查询线路限额，最大电流，可开放容量。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为线路mRID
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
double lineRatedI = sqliteDb.queryOneLineParam(args[2] + oneLineParamTableName, args[3]);
double lineMaxI = sqliteDb.queryMaxSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], -1);
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);
break;
}
case "mouseOverTF": {
// mouseOverTF为鼠标放置在公变上，查询公变容量，最大负荷，三相不平衡度。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为公变mRID
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
double tFRatedCap = sqliteDb.queryTFCap(args[2] + tfParamTableName, args[3]);
double tFMaxP = sqliteDb.queryMaxTFP(args[2] + transformerTableName + HistoryData.seasonTable, args[3], -1);
double[] ub = sqliteDb.queryTFUb(args[2] + transformerTableName + HistoryData.unbalanceTable, args[3], -1);
// 低压负荷接入相别
String phase = sqliteDb.queryMinIPhase(args[2] + transformerTableName + HistoryData.minITable, args[3], -1);
System.out.println(tFRatedCap + " " + tFMaxP + " " + ub[0] + " " + ub[1] + " " + phase);
break;
}
case "mouseClickSw": {
// mouseClickSw为鼠标点击开关上，查询线路限额，最大电流，可开放容量。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为开关mRID
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
double lineRatedI = sqliteDb.queryOneLineParam(args[2] + oneLineParamTableName, args[3]);
double lineMaxI = sqliteDb.queryMaxSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], -1);
double lineAvgI = sqliteDb.queryMaxSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], -2);
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[] seasonCluster1 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonClusterTable, args[3], 1, 96);
double[] seasonCluster2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonClusterTable, args[3], 2, 96);
double[] seasonCluster3 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonClusterTable, args[3], 3, 96);
double[] seasonCluster4 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonClusterTable, args[3], 4, 96);
double[] psCluster1 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.psClusterTable, args[3], 1, 96);
double[] psCluster2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.psClusterTable, args[3], 2, 96);
double[] psCluster3 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.psClusterTable, args[3], 3, 96);
double[] psCluster4 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.psClusterTable, args[3], 4, 96);
double[] seasonMax1 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], 1, 96);
double[] seasonMax2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], 2, 96);
double[] seasonMax3 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], 3, 96);
double[] seasonMax4 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], 4, 96);
for (int i = 0; i < 96; i++) {
System.out.println(lineRatedI + "," + seasonCluster1[i] + "," + seasonMax1[i] + "," + seasonCluster2[i] + "," + seasonMax2[i] + "," +
seasonCluster3[i] + "," + seasonMax3[i] + "," + seasonCluster4[i] + "," + seasonMax4[i]);
}
System.out.println();
for (int i = 0; i < 96; i++) {
System.out.println(lineRatedI + "," + psCluster1[i] + "," + seasonMax1[i] + "," + psCluster2[i] + "," + seasonMax2[i] + "," +
psCluster3[i] + "," + seasonMax3[i] + "," + psCluster4[i] + "," + seasonMax4[i]);
}
break;
}
case "mouseClickTF": {
// mouseClickTF为鼠标点击公变上，查询公变容量，最大负荷，三相不平衡度。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为公变mRID
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
double tFRatedCap = sqliteDb.queryTFCap(args[2] + tfParamTableName, args[3]);
double tFMaxI = sqliteDb.queryMaxTFP(args[2] + transformerTableName + HistoryData.seasonTable, args[3], -2);
double[] ub = sqliteDb.queryTFUb(args[2] + transformerTableName + HistoryData.unbalanceTable, args[3], -1);
// 负荷
double[] seasonMax1 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.seasonTable, args[3], 1, 96);
double[] seasonMax2 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.seasonTable, args[3], 2, 96);
double[] seasonMax3 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.seasonTable, args[3], 3, 96);
double[] seasonMax4 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.seasonTable, args[3], 4, 96);
double[] seasonCluster1 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.seasonClusterTable, args[3], 1, 96);
double[] seasonCluster2 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.seasonClusterTable, args[3], 2, 96);
double[] seasonCluster3 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.seasonClusterTable, args[3], 3, 96);
double[] seasonCluster4 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.seasonClusterTable, args[3], 4, 96);
double[] psCluster1 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.psClusterTable, args[3], 1, 96);
double[] psCluster2 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.psClusterTable, args[3], 2, 96);
double[] psCluster3 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.psClusterTable, args[3], 3, 96);
double[] psCluster4 = sqliteDb.querySeasonTFP(args[2] + transformerTableName + HistoryData.psClusterTable, args[3], 4, 96);
// 三相不平衡度
double[] seasonMaxUb1 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.ubMaxTable, args[3], 1, 96);
double[] seasonMaxUb2 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.ubMaxTable, args[3], 2, 96);
double[] seasonMaxUb3 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.ubMaxTable, args[3], 3, 96);
double[] seasonMaxUb4 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.ubMaxTable, args[3], 4, 96);
double[] seasonClusterUb1 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.seasonClusterTable, args[3], 1, 96);
double[] seasonClusterUb2 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.seasonClusterTable, args[3], 2, 96);
double[] seasonClusterUb3 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.seasonClusterTable, args[3], 3, 96);
double[] seasonClusterUb4 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.seasonClusterTable, args[3], 4, 96);
double[] psClusterUb1 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.psClusterTable, args[3], 1, 96);
double[] psClusterUb2 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.psClusterTable, args[3], 2, 96);
double[] psClusterUb3 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.psClusterTable, args[3], 3, 96);
double[] psClusterUb4 = sqliteDb.querySeasonTFUb(args[2] + transformerTableName + HistoryData.psClusterTable, args[3], 4, 96);
// 公变可开放容量
double[] cap1 = sqliteDb.queryAvailCap(args[2] + transformerTableName + HistoryData.tfAvailCapTable, args[3], 1, 96);
double[] cap2 = sqliteDb.queryAvailCap(args[2] + transformerTableName + HistoryData.tfAvailCapTable, args[3], 2, 96);
double[] cap3 = sqliteDb.queryAvailCap(args[2] + transformerTableName + HistoryData.tfAvailCapTable, args[3], 3, 96);
double[] cap4 = sqliteDb.queryAvailCap(args[2] + transformerTableName + HistoryData.tfAvailCapTable, args[3], 4, 96);
System.out.println(tFRatedCap + " " + tFMaxI + " " + ub[0] + " " + ub[1]);
break;
}
case "calAllPsWarnDev": {
// calAllPsWarnDev为统计所有馈线设备预警数量。args[1]为存储所有馈线数据的数据库文件的路径，args[2]为馈线数据库文件夹路径
availCapModel = new AvailCapModel();
availCapModel.createAllPsWarnTable(args[1], allPsWarnTable);
availCapModel.createAllPsLineWarnTable(args[1], allPsLineWarnTable);
availCapModel.createAllPsTfWarnTable(args[1], allPsTfWarnTable);
availCapModel.allPsWarnDev(args[1], allFeederNameTable, args[2], allPsWarnTable, allPsLineWarnTable, allPsTfWarnTable);
System.out.println();
break;
}
case "calTfUb": {
// tfUb为公变月三相不平衡度分析。args[1]为馈线数据库文件夹路径，args[2]为馈线名称
historyData = new HistoryData();
HistoryData.createTfMonthUbTable(args[1] + "\\" + args[2] + ".db", args[2] + tfMonthUbTableName);
historyData.tfMonthUb(args[2] + transformerTableName, args[1] + "\\" + args[2] + ".db",
args[2] + tfMonthUbTableName, args[2] + substationTableName,
args[2] + tfParamTableName, args[2] + transformerTableName + HistoryData.seasonTable,
args[2] + tfToLineTableName);
break;
}
case "calLinePassRate": {
// linePassRate为线路合格率分析。args[1]为馈线数据库文件夹路径，args[2]为馈线名称
historyData = new HistoryData();
historyData.createLinePassRateTable(args[1] + "\\" + args[2] + ".db", args[2] + linePassRateTableName);
historyData.linePassRate(args[1] + "\\" + args[2] + ".db", args[2] + feederTableName,
args[2] + substationTableName, args[2] + switchTableName,
args[2] + swToLineTableName, args[2] + oneLineParamTableName,
args[2] + linePassRateTableName);
break;
}
case "calTfOverLoadRate": {
// tfOverLoadRate为公变越限分析。args[1]为馈线数据库文件夹路径，args[2]为馈线名称
historyData = new HistoryData();
historyData.createTfOverLoadTable(args[1] + "\\" + args[2] + ".db", args[2] + tfOverLoadRateTableName);
historyData.tfOverLoad(args[1] + "\\" + args[2] + ".db", args[2] + feederTableName,
args[2] + substationTableName, args[2] + tfOverLoadRateTableName,
args[2] + transformerTableName, args[2] + tfParamTableName,
args[2] + transformerTableName + HistoryData.seasonTable, args[2] + tfToLineTableName);
break;
}
case "calMaxMinAvailCap": {
// calMaxMinAvailCap为分析可开放容量最大和最小两条线路。args[1]为存储所有馈线数据的数据库文件的路径，args[2]为馈线数据库文件夹路径
availCapModel = new AvailCapModel();
availCapModel.createMaxMinAvailCap(args[1], maxMinAvailCapTable);
availCapModel.maxMinAvailCap(args[1], allFeederNameTable, args[2], maxMinAvailCapTable);
System.out.println();
break;
}
case "allPsWarnDev": {
// allPsWarnDev为查询所有馈线设备预警数量。args[1]为存储所有馈线数据的数据库文件的路径
// hardLineNum为重载线路数量，overLineNum为超载线路数量，hardTfNum为重载配变数量，overTfNum为超载配变数量
SqliteDb sqliteDb = new SqliteDb(args[1]);
int hardLineNum = sqliteDb.queryWarnDevNum(allPsWarnTable, 1, 1);
int overLineNum = sqliteDb.queryWarnDevNum(allPsWarnTable, 2, 1);
int hardTfNum = sqliteDb.queryWarnDevNum(allPsWarnTable, 1, 2);
int overTfNum = sqliteDb.queryWarnDevNum(allPsWarnTable, 2, 2);
System.out.println(hardLineNum + " " + overLineNum + " " + hardTfNum + " " + overTfNum);
break;
}
case "allPsHardLine": {
// allPsHardLine为查询所有馈线重载线路。args[1]为存储所有馈线数据的数据库文件的路径
// hardLine为重载线路列表数据，属性devName;substation;maxI;switchName;ratedCurrent对应界面表格中
// 线路名、所属变电站、最大电流、智能开关、限额
SqliteDb sqliteDb = new SqliteDb(args[1]);
List<WarnLine> hardLine = sqliteDb.queryWarnLine(allPsLineWarnTable, 1);
System.out.println(hardLine.size());
break;
}
case "allPsOverLine": {
// allPsHardLine为查询所有馈线超载线路。args[1]为存储所有馈线数据的数据库文件的路径
// overLine为超载线路列表数据，属性devName;substation;maxI;switchName;ratedCurrent对应界面表格中
// 线路名、所属变电站、最大电流、智能开关、限额
SqliteDb sqliteDb = new SqliteDb(args[1]);
List<WarnLine> overLine = sqliteDb.queryWarnLine(allPsLineWarnTable, 2);
System.out.println(overLine.size());
break;
}
case "allPsHardTf": {
// allPsHardTf为查询所有馈线重载公变。args[1]为存储所有馈线数据的数据库文件的路径
// hardTf为重载公变列表数据，属性devName;lineName;substation;maxLoad;ratedCap对应界面表格中
// 配变名、线路、变电站、最大负荷、容量
SqliteDb sqliteDb = new SqliteDb(args[1]);
List<WarnTf> hardTf = sqliteDb.queryWarnTf(allPsTfWarnTable, 1);
System.out.println(hardTf.size());
break;
}
case "allPsOverTf": {
// allPsOverTf为查询所有馈线超载公变。args[1]为存储所有馈线数据的数据库文件的路径
// overTf为超载公变列表数据，属性devName;lineName;substation;maxLoad;ratedCap对应界面表格中配变名、线路、变电站、最大负荷、容量
SqliteDb sqliteDb = new SqliteDb(args[1]);
List<WarnTf> overTf = sqliteDb.queryWarnTf(allPsTfWarnTable, 2);
System.out.println(overTf.size());
break;
}
case "tfUb": {
// tfUb为公变月三相不平衡度查询。args[1]为存储所有馈线数据的数据库文件的路径，args[2]为馈线数据库文件夹路径
// tfUbs公变月三相不平衡度列表，属性devName为配变名称，ub为三项不平衡度数值
SqliteDb allPsDb = new SqliteDb(args[1]);
List<String> feeders = allPsDb.queryAllFeederName(allFeederNameTable); // 查询馈线名称
List<TfUb> tfUbs = new LinkedList<>();
for (String feeder : feeders) {
SqliteDb sqliteDb = new SqliteDb(args[2] + "\\" + feeder + ".db");
tfUbs.addAll(sqliteDb.queryTfMonthUb(feeder + tfMonthUbTableName));
}
System.out.println(tfUbs.size());
break;
}
case "tfUbDetail": {
// tfUb为公变月三相不平衡度点击显示具体查询。args[1]为存储所有馈线数据的数据库文件的路径，args[2]为馈线数据库文件夹路径
// tfUbs公变月三相不平衡度列表，属性devName;lineName;substation;maxLoad;ratedCap;monthUb对应界面表格中
// 配变名、线路、变电站、最大负荷、容量、一个月的三相不平衡度数值
SqliteDb allPsDb = new SqliteDb(args[1]);
List<String> feeders = allPsDb.queryAllFeederName(allFeederNameTable); // 查询馈线名称
List<TfUb> tfUbs = new LinkedList<>();
for (String feeder : feeders) {
SqliteDb sqliteDb = new SqliteDb(args[2] + "\\" + feeder + ".db");
tfUbs.addAll(sqliteDb.queryTfMonthUb(feeder + tfMonthUbTableName));
}
System.out.println(tfUbs.size());
break;
}
case "linePassRate": {
// linePassRate为查询线路电流合格率。args[1]为馈线数据库文件夹路径，args[2]为查询的馈线名称
// LinePassRates为线路电流合格率结果列表，属性passRate为春夏秋冬的合格率数组
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
List<LinePassRate> linePassRates = sqliteDb.queryLinePassRate(args[2] + linePassRateTableName);
System.out.println(linePassRates.size());
break;
}
case "tfOverLoadRate": {
// tfOverLoadRate为查询公变越限分析结果。args[1]为存储所有馈线数据的数据库文件的路径，args[2]为馈线数据库文件夹路径
// tfOverLoadRates为公变越限分析结果列表，属性overLoadRate为春夏秋冬的越限率数组
SqliteDb allPsDb = new SqliteDb(args[1]);
List<String> feeders = allPsDb.queryAllFeederName(allFeederNameTable); // 查询馈线名称
List<TfOverLoadRate> tfOverLoadRates = new LinkedList<>();
for (String feeder : feeders) {
SqliteDb sqliteDb = new SqliteDb(args[2] + "\\" + feeder + ".db");
tfOverLoadRates.addAll(sqliteDb.queryTfOverLoadRate(feeder + tfOverLoadRateTableName));
}
System.out.println(tfOverLoadRates.size());
break;
}
case "maxMinAvailCap": {
// maxMinAvailCap为查询可开放容量最大和最小两条线路。args[1]为存储所有馈线数据的数据库文件的路径
// maxFeeder为可开放容量最大线路，minFeeder为可开放容量最小线路，属性feederName为线路名称、availCap为可开放容量数值
SqliteDb sqliteDb = new SqliteDb(args[1]);
MaxMinAvailCap maxFeeder = sqliteDb.queryMaxMinAvailCap(maxMinAvailCapTable, 1);
MaxMinAvailCap minFeeder = sqliteDb.queryMaxMinAvailCap(maxMinAvailCapTable, 2);
System.out.println(maxFeeder.feederName + " " + maxFeeder.availCap);
System.out.println(minFeeder.feederName + " " + minFeeder.availCap);
break;
}
case "baseInfo": {
// baseInfo为开关基础信息，查询线路限额，最大电流，平均电流。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为开关mRID
// lineRatedI为最大限额，lineMaxI为最大电流，avgI为平均电流
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
double lineRatedI = sqliteDb.queryOneLineParam(args[2] + oneLineParamTableName, args[3]);
double lineMaxI = sqliteDb.queryMaxSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], -1);
double avgI = sqliteDb.queryMaxSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], -2);
System.out.println(lineRatedI + " " + lineMaxI + " " + avgI);
break;
}
case "lineSummer": {
// lineSummer为线路夏季分析。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为开关mRID
// lineRatedICv为线路限额，seasonCluster2为负荷聚类曲线，seasonMax2为最大负荷曲线，cap2为可开放容量
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
double lineRatedI = sqliteDb.queryOneLineParam(args[2] + oneLineParamTableName, args[3]);
double[] lineRatedICv = new double[96];
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[] cap2 = sqliteDb.queryAvailCap(args[2] + availCapTableName, args[3], 2, 96);
System.out.println();
break;
}
case "lineWinter": {
// lineWinter为线路冬季分析。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为开关mRID
// lineRatedICv为线路限额，seasonCluster4为负荷聚类曲线，seasonMax4为最大负荷曲线，cap4为可开放容量
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
double lineRatedI = sqliteDb.queryOneLineParam(args[2] + oneLineParamTableName, args[3]);
double[] lineRatedICv = new double[96];
for (int i = 0; i < 96; i++) {
lineRatedICv[i] = lineRatedI;
}
double[] seasonCluster4 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonClusterTable, args[3], 4, 96);
double[] seasonMax4 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], 4, 96);
double[] cap4 = sqliteDb.queryAvailCap(args[2] + availCapTableName, args[3], 4, 96);
System.out.println();
break;
}
case "linePs": {
// linePs为线路峰谷分析。args[1]为馈线数据库文件夹的路径，args[2]为馈线名称，args[3]为开关mRID
// lineRatedICv为线路限额，psCluster2为负荷聚类曲线，seasonMax2为最大负荷曲线，cap2为可开放容量
SqliteDb sqliteDb = new SqliteDb(args[1] + "\\" + args[2] + ".db");
double lineRatedI = sqliteDb.queryOneLineParam(args[2] + oneLineParamTableName, args[3]);
double[] lineRatedICv = new double[96];
for (int i = 0; i < 96; i++) {
lineRatedICv[i] = lineRatedI;
}
double[] psCluster2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.psClusterTable, args[3], 2, 96);
double[] seasonMax2 = sqliteDb.querySeasonSwitchI(args[2] + switchTableName + HistoryData.seasonTable, args[3], 2, 96);
double[] cap2 = sqliteDb.queryAvailCap(args[2] + availCapTableName, args[3], 2, 96);
System.out.println();
break;
}
case "loadPosSeason": {
// loadPosSeason为查询负荷接入分析结果。args[1]为存储所有馈线数据的数据库文件的路径
// loadPosSeason为负荷接入分析结果列表，属性substation;feederName;canIn;tfName;phase;time对应界面表格的
// 变电站、线路名称、能否接入、接入点、接入相别、分析时间
SqliteDb sqliteDb = new SqliteDb(args[1]);
List<LoadPosSeason> loadPosSeason = sqliteDb.queryLoadPosSeason(loadPosTable, 1);
System.out.println(loadPosSeason.size());
break;
}
case "loadPosSw": {
// loadPosSw为查询高压情况负荷接入分析结果。args[1]为存储所有馈线数据的数据库文件的路径，args[2]为loadId（从loadPosSeason属性获取）
// loadPosSw为高压情况负荷接入分析结果，属性canIn为是否能接入，swName为接入点智能开关名称，newLoadI为接入负荷电流曲线，
// swOrgLoad为接入前接入点负荷电流曲线，swNewLoad为接入后负荷电流曲线，swRateI为限额
SqliteDb sqliteDb = new SqliteDb(args[1]);
LoadPosSw loadPosSw = sqliteDb.queryLoadPosSw(loadPosTable, Integer.parseInt(args[2]), 1);
System.out.println();
break;
}
case "loadPosTf": {
// loadPosTf为查询低压情况负荷接入分析结果。args[1]为数据库文件的路径，args[2]为loadId（从loadPosSeason属性获取）
// loadPosTf为低压情况负荷接入分析结果，属性canIn为是否能接入，tfName为接入点，phase为接入相别，newLoad为接入负荷电流曲线，
// tfOrgLoad为接入前接入点负荷电流曲线，tfNewLoad为接入后负荷电流曲线，tfRateCap为限额
SqliteDb sqliteDb = new SqliteDb(args[1]);
LoadPosTf loadPosTf = sqliteDb.queryLoadPosTf(loadPosTable, Integer.parseInt(args[2]), 1);
System.out.println();
break;
}
}
}
}
availCap/src/main/java/AvailCapModel.java 0 → 100644
import org.jgrapht.UndirectedGraph;
import zju.devmodel.MapObject;
import java.util.*;
import static java.lang.Math.sqrt;
public class AvailCapModel {
JyPowerSystem ps;
Map<Edge, double[][]> edgeAvailCap = new HashMap<>();
List<Edge> edges;
Map<String, Edge> idToEdge = new HashMap<>();
Map<String, Integer> edgeDist = new HashMap<>();
Map<String, int[]> cnsPath = new HashMap<>();
String[] loadPos = new String[4];
int T = 15; // 采点时间间隔
int pointNum = 24 * 60 / T;
double JKsm = 1.09;
double JKwin = 1.52;
double LGJsm = 0.88;
double LGJwin = 1.15;
public AvailCapModel(JyPowerSystem ps) {
this.ps = ps;
}
public AvailCapModel() {};
/**
* 创建变电站名称表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createSubStationNameTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" substation varchar(200) NOT NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 存储变电站名称
*/
public void saveSubstationName(String substationNameTable, String dbFile, String substationName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + substationNameTable + " values(" +
"'" + substationName + "')";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
/**
* 创建线路限额表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createOneLineParamTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName varchar(200) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" ratedCurrent decimal(6,2) NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建可装容量分析结果表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createAvailCapTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName varchar(50) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" availCap decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建负荷接入分析结果表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createLoadPosTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
if (!sqliteDb.existTable(tableName)) {
String initSql = "CREATE TABLE " + tableName + " (" +
" loadId INTEGER NOT NULL," +
" substation varchar(20) NOT NULL," +
" feederName varchar(20) NOT NULL," +
" season INTEGER NULL," +
" canIn varchar(8) NOT NULL," +
" tfName varchar(50) NOT NULL," +
" tfMRID varchar(50) NOT NULL," +
" phase varchar(8) NOT NULL," +
" time varchar(20) NOT NULL," +
" swName varchar(50) NOT NULL," +
" swMRID varchar(50) NOT NULL," +
" newLoadI varchar(1000) NULL, " +
" swOrgLoad varchar(1000) NULL, " +
" swNewLoad varchar(1000) NULL, " +
" swRateI decimal(6,2) NULL, " +
" newLoad varchar(1000) NULL, " +
" tfOrgLoad varchar(1000) NULL, " +
" tfNewLoad varchar(1000) NULL, " +
" tfRateCap decimal(6,2) NULL " +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
}
/**
* 创建开关对应公变、公变对应开关的表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createSwToTfTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName1 varchar(50) NOT NULL," +
" mRID1 varchar(50) NOT NULL," +
" devName2 varchar(50) NOT NULL," +
" mRID2 varchar(50) NOT NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建公变对应线路的表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createTfToLineTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName1 varchar(50) NOT NULL," +
" mRID1 varchar(50) NOT NULL," +
" devName2 varchar(50) NOT NULL," +
" mRID2 varchar(50) NOT NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建开关对应线路、线路对应开关的表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createSwToLineTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName1 varchar(50) NOT NULL," +
" mRID1 varchar(50) NOT NULL," +
" devName2 varchar(50) NOT NULL," +
" mRID2 varchar(50) NOT NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建线路预警表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createLineWarnTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" loadState INTEGER NULL," + // 1为重载，2为超载
" devName varchar(200) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" substation varchar(20) NOT NULL," +
" switchName varchar(200) NOT NULL," +
" switchMRID varchar(50) NOT NULL," +
" maxI decimal(6,2) NULL," +
" ratedCurrent decimal(6,2) NULL," +
" loadRate decimal(4,5) NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建公变预警表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createTfWarnTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" loadState INTEGER NULL," + // 1为重载，2为超载
" devName varchar(200) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" lineName varchar(200) NOT NULL," +
" lineMRID varchar(50) NOT NULL," +
" substation varchar(20) NOT NULL," +
" maxLoad decimal(8,4) NULL," +
" ratedCap decimal(4,0) NULL," +
" loadRate decimal(4,5) NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建所有馈线名称表格
* @param allPsDbFile 数据库路径
* @param tableName 表名
*/
public void createAllFeederNameTable(String allPsDbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(allPsDbFile);
if (!sqliteDb.existTable(tableName)) {
String initSql = "CREATE TABLE " + tableName + " (" +
" feeder varchar(200) NOT NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
}
/**
* 存储所有馈线名称表格
* @param allPsDbFile 数据库路径
* @param tableName 表名
*/
public void saveAllFeederNameTable(String allPsDbFile, String tableName, String feederName) {
SqliteDb sqliteDb = new SqliteDb(allPsDbFile);
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + tableName + " values(" +
"'" + feederName + "')";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
/**
* 创建所有馈线预警表格
* @param allPsDbFile 数据库路径
* @param tableName 表名
*/
public void createAllPsWarnTable(String allPsDbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(allPsDbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" loadState INTEGER NULL," + // 1为重载，2为超载
" type INTEGER NULL," + // 1为线路，2为配变
" number INTEGER NULL" + // 数量
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建所有馈线线路预警表格
* @param allPsDbFile 数据库路径
* @param tableName 表名
*/
public void createAllPsLineWarnTable(String allPsDbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(allPsDbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" loadState INTEGER NULL," + // 1为重载，2为超载
" devName varchar(200) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" substation varchar(20) NOT NULL," +
" switchName varchar(200) NOT NULL," +
" switchMRID varchar(50) NOT NULL," +
" maxI decimal(6,2) NULL," +
" ratedCurrent decimal(6,2) NULL," +
" loadRate decimal(4,5) NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建所有馈线公变预警表格
* @param allPsDbFile 所有馈线数据库路径
* @param tableName 表名
*/
public void createAllPsTfWarnTable(String allPsDbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(allPsDbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" loadState INTEGER NULL," + // 1为重载，2为超载
" devName varchar(200) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" lineName varchar(200) NOT NULL," +
" lineMRID varchar(50) NOT NULL," +
" substation varchar(20) NOT NULL," +
" maxLoad decimal(8,4) NULL," +
" ratedCap decimal(4,0) NULL," +
" loadRate decimal(4,5) NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建线路可开放容量最大和最小两条表格
* @param allPsDbFile 所有馈线数据库路径
* @param tableName 表名
*/
public void createMaxMinAvailCap(String allPsDbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(allPsDbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" maxOrMin INTEGER NULL," + // 1为最大，2为最小
" feederName varchar(200) NOT NULL," +
" availCap decimal(8,4) NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
public void buildPaths() {
if (ps.getSourceCns().isEmpty()) {
System.out.println("No source find while build paths");
return;
}
String supplyCn = ps.getSourceCns().get(0);
UndirectedGraph<String, Edge> g = ps.getActiveIslands().get(0);
edges = new ArrayList<>(g.edgeSet());
for (Edge edge : edges) {
idToEdge.put(edge.getEquips().get(0), edge);
}
// 初始化节点为未访问状态
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;
edgeDist.put(e.getEquips().getFirst().substring(3), edgeStack.size());
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);
int[] path = new int[edges.size()];
for (Edge edge : edgeStack) {
for (int i = 0; i < edges.size(); i++) {
if (edges.get(i).equals(edge)) {
path[i] = 1;
break;
}
}
}
cnsPath.put(neighbor, path);
break;
}
if (noPush) {
visited.put(stack.pop(), true);
if (!edgeStack.isEmpty()) {
edgeStack.pop();
}
}
}
}
/**
* 存储智能开关对应的公变，公变对应的智能开关，公变对应的线路
*/
public void switchToTf(String switchTableName, String dbFile, String swToTfTableName, String tfToLineTableName) {
// 获取开关的mRId
SqliteDb sqliteDb = new SqliteDb(dbFile);
List<String> mRIDs = sqliteDb.queryMRIds(switchTableName);
if (ps.getSourceCns().isEmpty()) {
System.out.println("No source find while build paths");
return;
}
String supplyCn = ps.getSourceCns().get(0);
UndirectedGraph<String, Edge> g = ps.getActiveIslands().get(0);
// 初始化节点为未访问状态
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<>();
Deque<String> switchStack = new ArrayDeque<>(); // 存储开关的栈
Deque<String> lineStack = 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;
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);
// 智能开关数据库中查找
String eId = e.getEquips().getFirst();
if (ps.isSwitch(eId) && mRIDs.contains(eId.substring(3))) {
switchStack.push(eId);
}
// 线路入栈
if (ps.getResource(eId).getType().equals("ACLINESEGMENT")) {
lineStack.push(eId);
}
break;
}
if (noPush) {
visited.put(stack.pop(), true);
if (!edgeStack.isEmpty()) {
Edge e = edgeStack.pop();
String eId = e.getEquips().getFirst();
if (ps.getResource(eId).getType().equals("POWERTRANSFORMER")) {
String tfName = ps.getResource(eId).getProperty("NAME");
// 存开关和公变对应数据
if (switchStack.size() > 0) {
String swId = switchStack.peek();
String swName = ps.getResource(swId).getProperty("NAME");
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + swToTfTableName + " values(" +
"'" + swName + "','" + swId.substring(3) +
"','" + tfName + "','" + eId.substring(3) + "')";
sqls.add(insertSql);
insertSql = "insert into " + swToTfTableName + " values(" +
"'" + tfName + "','" + eId.substring(3) +
"','" + swName + "','" + swId.substring(3) + "')";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
// 存公变和线路对应数据
if (lineStack.size() > 0 ) {
String lineId = lineStack.peek();
String lineName = ps.getResource(lineId).getProperty("NAME");
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + tfToLineTableName + " values(" +
"'" + tfName + "','" + eId.substring(3) +
"','" + lineName + "','" + lineId.substring(3) + "')";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
// 智能开关数据库中查找
if (ps.isSwitch(eId) && mRIDs.contains(eId.substring(3))) {
switchStack.pop();
}
// 线路
if (ps.getResource(eId).getType().equals("ACLINESEGMENT")) {
lineStack.pop();
}
}
}
}
}
/**
* 存储智能开关对应的线路，线路对应的智能开关
*/
public void switchToLine(String switchTableName, String dbFile, String swToLineTableName) {
// 获取开关的mRId
SqliteDb sqliteDb = new SqliteDb(dbFile);
List<String> mRIDs = sqliteDb.queryMRIds(switchTableName);
if (ps.getSourceCns().isEmpty()) {
System.out.println("No source find while build paths");
return;
}
String supplyCn = ps.getSourceCns().get(0);
UndirectedGraph<String, Edge> g = ps.getActiveIslands().get(0);
// 初始化节点为未访问状态
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<>();
String switchEdge = null; // 线路段开关
List<String> lines = new LinkedList<>(); // 线路段
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;
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);
String eId = e.getEquips().getFirst();
if (stack.size() > 2 && g.edgesOf(cn).size() > 2) {
// 存库
if (switchEdge != null) {
List<String> sqls = new LinkedList<>();
for (String line : lines) {
String swName = ps.getResource(switchEdge).getProperty("NAME");
String lineName = ps.getResource(line).getProperty("NAME");
String insertSql = "insert into " + swToLineTableName + " values(" +
"'" + swName + "','" + switchEdge.substring(3) +
"','" + lineName + "','" + line.substring(3) + "')";
sqls.add(insertSql);
insertSql = "insert into " + swToLineTableName + " values(" +
"'" + lineName + "','" + line.substring(3) +
"','" + swName + "','" + switchEdge.substring(3) + "')";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
lines.clear();
switchEdge = null;
}
if (ps.getResource(eId).getType().equals("ACLINESEGMENT")) {
lines.add(eId);
}
// 智能开关数据库中查找
if (ps.isSwitch(eId) && mRIDs.contains(eId.substring(3))) {
switchEdge = eId;
}
break;
}
if (noPush) {
visited.put(stack.pop(), true);
if (!edgeStack.isEmpty()) {
edgeStack.pop();
}
}
}
}
public void calAvailCap(String resultTableName, String switchTableName, String dbFile) {
if (ps.getSourceCns().isEmpty()) {
System.out.println("No source find while calculate avail capacity");
return;
}
String supplyCn = ps.getSourceCns().get(0);
UndirectedGraph<String, Edge> g = ps.getActiveIslands().get(0);
// 初始化节点为未访问状态
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;
String neighbor = g.getEdgeTarget(e);
if (neighbor.equals(cn))
neighbor = g.getEdgeSource(e);
// 如果顶点已经被遍历过，则不进行处理
if (visited.get(neighbor))
continue;
// 未遍历过的节点
stack.push(neighbor);
noPush = false;
double[][] availCap = edgeAvailCap.get(e);
for (Edge edge : edgeStack) {
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;
// }
}
}
}
}
edgeAvailCap.put(e, availCap);
edgeStack.push(e);
break;
}
if (noPush) {
visited.put(stack.pop(), true);
if (!edgeStack.isEmpty()) {
edgeStack.pop();
}
}
}
// 存储可接入容量数据
SqliteDb sqliteDb = new SqliteDb(dbFile);
List<String> mRIDs = sqliteDb.queryMRIds(switchTableName);
for (String mRID : mRIDs) {
Edge edge = idToEdge.get("PD_" + mRID);
if (edge != null) {
double[][] availCap = edgeAvailCap.get(edge);
for (int season = 1; season < 5; season++) {
List<String> sqls = new LinkedList<>();
for (int j = 0; j < pointNum; j++) {
// 电流不转成容量
String insertSql = "insert into " + resultTableName + " values(" +
"'" + ps.getResource(edge.getEquips().get(0)).getProperty("NAME") + "','" + mRID +
"'," + season + "," + availCap[season - 1][j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
}
}
public LoadPos loadPosOpt(double[] load, String swTableName, String availCapTableName, String dbFile,
String substationTable, String feederTable, String oneLineParamTable, String swClusterTable,
String swToTfTable, String tfParamTable, String tfAvailCapTable, String tfClusterTable,
String tfMinITable, String allPsdbFile, String loadPosTable) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
// 查询变电站名称
String substation = sqliteDb.querySubstationName(substationTable);
// 查询馈线名称
String feeder = sqliteDb.queryFeederName(feederTable);
double[] loadI = new double[pointNum];
loadI[0] = load[0] / 10 / sqrt(3);
StringBuilder newLoad = new StringBuilder(String.valueOf(load[0]));
StringBuilder newLoadI = new StringBuilder(String.valueOf(loadI[0]));
for (int i = 1; i < pointNum; i++) {
loadI[i] = load[i] / 10 / sqrt(3);
newLoad.append(";").append(load[i]);
newLoadI.append(";").append(loadI[i]);
}
LoadPos loadPos = new LoadPos();
loadPos.setNewLoad(load);
loadPos.setNewLoadI(loadI);
List<String> mRIDs = sqliteDb.queryMRIds(swTableName);
// 最优开关
String[] optEdge = new String[]{mRIDs.get(0), mRIDs.get(0), mRIDs.get(0), mRIDs.get(0)};
double[] seasonAvgCap = new double[4]; // 负荷接入后裕度平均值
double[] seasonMinCap = new double[4]; // 负荷接入后裕度最小值
// 次优的开关
String[] optEdge2 = new String[]{mRIDs.get(0), mRIDs.get(0), mRIDs.get(0), mRIDs.get(0)};
double[] seasonAvgCap2 = new double[4];
double[] seasonMinCap2 = new double[4];
// 存储是否存在最优和次优的开关
boolean[] hasFirst = new boolean[]{false, false, false, false};
boolean[] hasSecond = new boolean[]{false, false, false, false};
for (int season = 0; season < 4; season++) {
for (String mRID : mRIDs) {
double[] cap = sqliteDb.queryAvailCap(availCapTableName, mRID, season + 1, pointNum);
double avgCap = 0;
double minCap = Double.MAX_VALUE;
boolean hasNag = false;
for (int i = 0; i < pointNum; i++) {
double resCap = cap[i] - loadI[i];
if (resCap < 0) {
hasNag = true;
break;
}
avgCap += resCap;
if (minCap > resCap) {
minCap = resCap;
}
}
if (hasNag)
break;
avgCap = avgCap / pointNum;
if (avgCap + minCap > seasonAvgCap[season] + seasonMinCap[season]) {
// 存储次优数据
optEdge2[season] = optEdge[season];
seasonAvgCap2[season] = seasonAvgCap[season];
seasonMinCap2[season] = seasonMinCap[season];
if (hasFirst[season])
hasSecond[season] = true;
// 存储最优数据
optEdge[season] = mRID;
seasonAvgCap[season] = avgCap;
seasonMinCap[season] = minCap;
hasFirst[season] = true;
} else if (avgCap + minCap == seasonAvgCap[season] + seasonMinCap[season]) {
// 优先接在离主线近的位置
// 存储次优数据
seasonAvgCap2[season] = seasonAvgCap[season];
seasonMinCap2[season] = seasonMinCap[season];
if (hasFirst[season])
hasSecond[season] = true;
// 存储最优数据
if (hasFirst[season]) {
if (edgeDist.get(mRID) < edgeDist.get(optEdge[season])) {
optEdge2[season] = optEdge[season];
optEdge[season] = mRID;
} else {
if (hasSecond[season]) {
if (edgeDist.get(mRID) < edgeDist.get(optEdge2[season])) {
optEdge2[season] = mRID;
}
} else {
optEdge2[season] = mRID;
}
}
}
}
}
// 时间
long t = System.currentTimeMillis();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(t);
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH) + 1;
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
String time = year + "." + month + "." + day + " " + hour + ":" + minutes;
SqliteDb allPsDb = new SqliteDb(allPsdbFile);
int loadId = allPsDb.queryMaxLoadId(loadPosTable) + 1;
if (hasFirst[season]) {
MapObject edge = ps.getResource("PD_" + optEdge[season]);
if (edge != null) {
loadPos.addLoadPos(season, optEdge[season], edge.getProperty("NAME"), seasonAvgCap[season], seasonMinCap[season]);
} else {
loadPos.addLoadPos(season, optEdge[season], "", seasonAvgCap[season], seasonMinCap[season]);
}
// System.out.println(season + " " + optEdge[season] + " " + seasonAvgCap[season] + " " + seasonMinCap[season]);
// 查询开关的限额
double swRatedI = sqliteDb.queryOneLineParam(oneLineParamTable, optEdge[season]);
loadPos.getSwRateI()[season] = swRatedI;
// 查询开关聚类电流
double[] swCluster = sqliteDb.querySeasonSwitchI(swClusterTable, optEdge[season], season + 1, pointNum);
loadPos.setSwOrgLoad(season, swCluster);
loadPos.calSwNewLoad(season);
// 查询开关对应的公变
List<String[]> tfs = sqliteDb.querySwToDev(swToTfTable, optEdge[season]);
boolean tfCanIn = false;
double optTfRateCap = 400;
String optTf = null;
String optTfName = null;
double maxSumAvailCap = 0;
for (String[] tf : tfs) {
// 查询公变可开放容量
double[] tfAvailCap = sqliteDb.queryAvailCap(tfAvailCapTable, tf[1], season + 1, pointNum);
boolean canIn = true;
double sumAvailCap = 0;
for (int i = 0; i < pointNum; i++) {
sumAvailCap += tfAvailCap[i];
if (tfAvailCap[i] < load[i]) {
canIn = false;
break;
}
}
if (!canIn)
continue;
tfCanIn = true;
optTfRateCap = sqliteDb.queryTFCap(tfParamTable, tf[1]);
if (sumAvailCap > maxSumAvailCap) {
maxSumAvailCap = sumAvailCap;
optTf = tf[1];
optTfName = tf[0];
}
}
loadPos.getCanIn()[season] = tfCanIn;
if (tfCanIn) {
loadPos.getTfRateCap()[season] = optTfRateCap;
loadPos.getOptTfs()[season] = optTf;
loadPos.getOptTfNames()[season] = optTfName;
// 查询公变聚类负荷
double[] tfCluster = sqliteDb.querySeasonTFP(tfClusterTable, optTf, season + 1, pointNum);
for (int i = 0; i < pointNum; i++) {
tfCluster[i] /= 1000;
}
loadPos.setTfOrgLoad(season, tfCluster);
loadPos.calTfNewLoad(season);
// 查询公变接入相别
String phase = sqliteDb.queryMinIPhase(tfMinITable, optTf, season + 1);
loadPos.getOptPhase()[season] = phase;
StringBuilder swOrgLoad = new StringBuilder(String.valueOf(loadPos.getSwOrgLoad()[season][0]));
StringBuilder swNewLoad = new StringBuilder(String.valueOf(loadPos.getSwNewLoad()[season][0]));
StringBuilder tfOrgLoad = new StringBuilder(String.valueOf(loadPos.getTfOrgLoad()[season][0]));
StringBuilder tfNewLoad = new StringBuilder(String.valueOf(loadPos.getTfNewLoad()[season][0]));
for (int i = 1; i < pointNum; i++) {
swOrgLoad.append(";").append(loadPos.getSwOrgLoad()[season][i]);
swNewLoad.append(";").append(loadPos.getSwNewLoad()[season][i]);
tfOrgLoad.append(";").append(loadPos.getTfOrgLoad()[season][i]);
tfNewLoad.append(";").append(loadPos.getTfNewLoad()[season][i]);
}
List<String> sqls = new LinkedList<>();
// 开关电流，公变容量kW
String insertSql = "insert into " + loadPosTable + " values(" +
loadId + ",'" + substation + "','" + feeder + "'," + (season + 1) + ",'是','" + optTfName +
"','" + optTf + "','" + phase + "相','" + time + "','" + optEdge[season] + "','" + edge.getProperty("NAME") +
"','" + newLoadI + "','" + swOrgLoad + "','" + swNewLoad + "'," + loadPos.getSwRateI()[season] +
",'" + newLoad + "','" + tfOrgLoad + "','" + tfNewLoad + "'," + optTfRateCap + ")";
sqls.add(insertSql);
allPsDb.executeSqls(sqls);
sqls.clear();
} else {
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + loadPosTable + " values(" +
loadId + ",'" + substation + "','" + feeder + "'," + (season + 1) + ",'否','" + "" +
"','" + "" + "','" + "" + "','" + time + "','" + "" + "','" + "" +
"','" + newLoad + "','" + "" + "','" + "" + "'," + 0 +
",'" + newLoadI + "','" + "" + "','" + "" + "'," + 0 + ")";
sqls.add(insertSql);
allPsDb.executeSqls(sqls);
sqls.clear();
}
} else {
loadPos.getCanIn()[season] = false;
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + loadPosTable + " values(" +
loadId + ",'" + substation + "','" + feeder + "'," + (season + 1) + ",'否','" + " " +
"','" + "" + "','" + "" + "','" + time + "','" + "" + "','" + "" +
"','" + newLoad + "','" + "" + "','" + "" + "'," + 0 +
",'" + newLoadI + "','" + "" + "','" + "" + "'," + 0 + ")";
sqls.add(insertSql);
allPsDb.executeSqls(sqls);
sqls.clear();
}
if (hasSecond[season]) {
MapObject edge = ps.getResource("PD_" + optEdge2[season]);
if (edge != null) {
loadPos.addLoadPos2(season, optEdge2[season], edge.getProperty("NAME"), seasonAvgCap2[season], seasonMinCap2[season]);
} else {
loadPos.addLoadPos2(season, optEdge2[season], "", seasonAvgCap2[season], seasonMinCap2[season]);
}
// System.out.println(season + " " + optEdge2[season] + " " + seasonAvgCap2[season] + " " + seasonMinCap2[season]);
}
}
return loadPos;
}
/**
* 设置支路电流限值
* @param tableName 表名
* @param dbFile 数据库名
*/
public void setEdgeLimI(String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
// 读取两个杆的名称
List<LineParamData> lineParamDatas = sqliteDb.queryLineParam(tableName);
for (LineParamData lineParamData : lineParamDatas) {
String cn1 = ps.getPoleNameToCn().get(lineParamData.getPole1());
String cn2 = ps.getPoleNameToCn().get(lineParamData.getPole2());
if (cn1 != null && cn2 != null) {
double limI = lineParamData.getRatedI();
int[] path1 = cnsPath.get(cn1);
int[] path2 = cnsPath.get(cn2);
for (int i = 0; i < edges.size(); i++) {
if (path1[i] + path2[i] == 1) {
Edge e = edges.get(i);
e.setType(lineParamData.getType());
if (e.getLimI() > limI) {
e.setLimI(limI);
}
}
}
}
}
}
/**
* 设置支路电流限值并存库
* @param tableName 表名
* @param dbFile 数据库名
* @param oneLineTableName 单线参数表名
*/
public void setEdgeLimI(String tableName, String dbFile, String oneLineTableName) {
setEdgeLimI(tableName, dbFile);
SqliteDb sqliteDb = new SqliteDb(dbFile);
List<String> sqls = new LinkedList<>();
for (Edge e : edges) {
String insertSql = "insert into " + oneLineTableName + " values(" +
"'" + ps.getResource(e.getEquips().get(0)).getProperty("NAME") +
"','" + e.getEquips().get(0).substring(3) + "'," + e.getLimI() + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
/**
* 根据支路电流历史季度电流最大值，设置单支路电流裕度
* @param lineISeasontableName 线路电流按季度分析结果表名
* @param swISeasontableName 开关电流按季度分析结果表名
* @param dbFile 数据库名
*/
public void setEdgeAvailCap(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];
}
}
}
}
// for (UndirectedGraph<String, Edge> g : ps.getActiveIslands()) {
for (Edge e : g.edgeSet()) {
double[][] availCap = new double[4][pointNum];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < pointNum; j++) {
availCap[i][j] = mainLineAvailCap[i][j];
}
}
for (int season = 1; season < 5; season++) {
for (String equip : e.getEquips()) {
String mRID = equip.substring(3);
double[] I = sqliteDb.querySeasonSwitchI(swISeasontableName, mRID, season, pointNum);
double limI = e.getLimI();
int type = e.getType();
for (int i = 0; i < pointNum; i++) {
if (season == 2 || season == 3) {
if (type == 1) {
if (availCap[season - 1][i] > limI * JKsm - I[i]) {
availCap[season - 1][i] = limI * JKsm - I[i];
}
} else if (type == 2) {
if (availCap[season - 1][i] > limI * LGJsm - I[i]) {
availCap[season - 1][i] = limI * LGJsm - I[i];
}
}
} else {
if (type == 1) {
if (availCap[season - 1][i] > limI * JKwin - I[i]) {
availCap[season - 1][i] = limI * JKwin - I[i];
}
} else if (type == 2) {
if (availCap[season - 1][i] > limI * LGJwin - I[i]) {
availCap[season - 1][i] = limI * LGJwin - I[i];
}
}
}
}
}
}
edgeAvailCap.put(e, availCap);
}
// }
}
/**
* 设备预警分析
*/
public void warnDevAnalysis(String dbFile, String substationTable, String tfWarnTable, String tfTable, String tfParamTable, String tfSeasonTable,
String tfToLineTable, String swTable, String swToLineTable, String oneLineParamTable,
String swSeasonTable, String lineWarnTable) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
// 查询变电站名称
String substation = sqliteDb.querySubstationName(substationTable);
// 分析公变
Map<String, String> tfNameToMRID = sqliteDb.queryNameToMRID(tfTable);
List<String> sqls = new LinkedList<>();
for (String name : tfNameToMRID.keySet()) {
String mRID = tfNameToMRID.get(name);
double tfRatedCap = sqliteDb.queryTFCap(tfParamTable, mRID);
double tfMaxP = sqliteDb.queryMaxTFP(tfSeasonTable, mRID, -1) / 1000;
double loadRate = tfMaxP / tfRatedCap;
// 公变对应的线路名称
List<String[]> lines = sqliteDb.querySwToDev(tfToLineTable, mRID);
if (lines.size() > 0) {
String[] line = lines.get(0);
if (loadRate < 2 && loadRate > 1) {
String insertSql = "insert into " + tfWarnTable + " values(" +
"2,'" + name + "','" + mRID + "','" + line[0] + "','" + line[1] + "','" + substation + "'," +
tfMaxP + "," + tfRatedCap + "," + loadRate + ")";
sqls.add(insertSql);
} else if (loadRate < 1 && loadRate > 0.8) {
String insertSql = "insert into " + tfWarnTable + " values(" +
"1,'" + name + "','" + mRID + "','" + line[0] + "','" + line[1] + "','" + substation + "'," +
tfMaxP + "," + tfRatedCap + "," + loadRate + ")";
sqls.add(insertSql);
}
}
}
sqliteDb.executeSqls(sqls);
sqls.clear();
// 分析线路（开关对应的线路）
Map<String, String> swNameToMRID = sqliteDb.queryNameToMRID(swTable);
for (String name : swNameToMRID.keySet()) {
String mRID = swNameToMRID.get(name);
List<String[]> lines = sqliteDb.querySwToDev(swToLineTable, mRID);
for (String[] line : lines) {
double lineRatedI = sqliteDb.queryOneLineParam(oneLineParamTable, line[1]);
double lineMaxI = sqliteDb.queryMaxSwitchI(swSeasonTable, mRID, -1);
double loadRate = lineMaxI / lineRatedI;
if (loadRate < 2 && loadRate > 1) {
String insertSql = "insert into " + lineWarnTable + " values(" +
"2,'" + line[0] + "','" + line[1] + "','" + substation + "','" + name + "','" + mRID +
"'," + lineMaxI + "," + lineRatedI + "," + loadRate + ")";
sqls.add(insertSql);
} else if (loadRate < 1 && loadRate > 0.8) {
String insertSql = "insert into " + lineWarnTable + " values(" +
"1,'" + line[0] + "','" + line[1] + "','" + substation + "','" + name + "','" + mRID +
"'," + lineMaxI + "," + lineRatedI + "," + loadRate + ")";
sqls.add(insertSql);
}
}
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
/**
* 所有馈线预警设备数量统计，详细信息存库
*/
public void allPsWarnDev(String allPsdbFile, String allFeederNameTable, String dbFilePath, String allPsWarnTable,
String allPsLineWarnTable, String allPsTfWarnTable) {
SqliteDb allPsDb = new SqliteDb(allPsdbFile);
// 查询馈线名称
List<String> feeders = allPsDb.queryAllFeederName(allFeederNameTable);
int[] warnLineNum = new int[2];
int[] warnTfNum = new int[2];
// 处理馈线数据库文件
for (String feeder : feeders) {
SqliteDb sqliteDb = new SqliteDb(dbFilePath + "\\" + feeder + ".db");
List<WarnLine> warnLines = sqliteDb.queryWarnLine(feeder + AvailCapMain.lineWarnTableName);
List<String> sqls = new LinkedList<>();
for (WarnLine warnLine : warnLines) {
if (warnLine.loadState == 1) {
warnLineNum[0]++;
} else {
warnLineNum[1]++;
}
String insertSql = "insert into " + allPsLineWarnTable + " values(" +
warnLine.loadState + ",'" + warnLine.devName + "','" + warnLine.mRID + "','" + warnLine.substation +
"','" + warnLine.switchName + "','" + warnLine.switchMRID + "'," + warnLine.maxI +
"," + warnLine.ratedCurrent + "," + warnLine.loadRate + ")";
sqls.add(insertSql);
}
allPsDb.executeSqls(sqls);
sqls.clear();
List<WarnTf> warnTfs = sqliteDb.queryWarnTf(feeder + AvailCapMain.tfWarnTableName);
for (WarnTf warnTf : warnTfs) {
if (warnTf.loadState == 1) {
warnTfNum[0]++;
} else {
warnTfNum[1]++;
}
String insertSql = "insert into " + allPsTfWarnTable + " values(" +
warnTf.loadState + ",'" + warnTf.devName + "','" + warnTf.mRID + "','" + warnTf.lineName + "','" +
warnTf.lineMRID + "','" + warnTf.substation + "'," + warnTf.maxLoad + "," + warnTf.ratedCap + "," + warnTf.loadRate + ")";
sqls.add(insertSql);
}
allPsDb.executeSqls(sqls);
sqls.clear();
}
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + allPsWarnTable + " values(" +
1 + "," + 1 + "," + warnLineNum[0] + ")";
sqls.add(insertSql);
insertSql = "insert into " + allPsWarnTable + " values(" +
2 + "," + 1 + "," + warnLineNum[1] + ")";
sqls.add(insertSql);
insertSql = "insert into " + allPsWarnTable + " values(" +
1 + "," + 2 + "," + warnTfNum[0] + ")";
sqls.add(insertSql);
insertSql = "insert into " + allPsWarnTable + " values(" +
2 + "," + 2 + "," + warnTfNum[1] + ")";
sqls.add(insertSql);
allPsDb.executeSqls(sqls);
sqls.clear();
}
/**
* 线路可开放容量最大和最小两条
*/
public void maxMinAvailCap(String allPsdbFile, String allFeederNameTable, String dbFilePath, String maxMinAvailCapTable) {
SqliteDb allPsDb = new SqliteDb(allPsdbFile);
// 查询馈线名称
List<String> feeders = allPsDb.queryAllFeederName(allFeederNameTable);
String maxFeederName = null;
double maxFeederAvailCap = 0;
String minFeederName = null;
double minFeederAvailCap = 1e8;
// 处理馈线数据库文件
for (String feeder : feeders) {
SqliteDb sqliteDb = new SqliteDb(dbFilePath + "\\" + feeder + ".db");
// 查询所有开关的mRID
List<String> mRIDs = sqliteDb.queryMRIds(feeder + AvailCapMain.switchTableName);
double maxLineAvailCap = 0;
for (String mRID : mRIDs) {
double avgAvailCap = 0;
int count = 0;
for (int season = 1; season < 5; season++) {
double[] availCap = sqliteDb.queryAvailCap(feeder + AvailCapMain.availCapTableName, mRID, season, pointNum);
for (int i = 0; i < pointNum; i++) {
avgAvailCap += availCap[i];
count++;
}
}
avgAvailCap /= count;
if (avgAvailCap > maxLineAvailCap) {
maxLineAvailCap = avgAvailCap;
}
}
if (maxLineAvailCap > maxFeederAvailCap) {
maxFeederAvailCap = maxLineAvailCap;
maxFeederName = feeder;
}
if (maxLineAvailCap < minFeederAvailCap) {
minFeederAvailCap = maxLineAvailCap;
minFeederName = feeder;
}
}
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + maxMinAvailCapTable + " values(" +
"1,'" + maxFeederName + "'," + maxFeederAvailCap + ")";
sqls.add(insertSql);
insertSql = "insert into " + maxMinAvailCapTable + " values(" +
"2,'" + minFeederName + "'," + minFeederAvailCap + ")";
sqls.add(insertSql);
allPsDb.executeSqls(sqls);
sqls.clear();
}
}
availCap/src/main/java/CimConstants.java 0 → 100644
public interface CimConstants {
//measurement value sources:
public static final String MEASURE_VALUE_SOURCE_SCADA = "SCADA";
//the following is not used usually
public static final String MEASURE_VALUE_SOURCE_PMU = "PMU";
public static final String MEASURE_VALUE_SOURCE_SE = "SE";//todo:
}
availCap/src/main/java/HistoryData.java 0 → 100644
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import zju.matrix.Complex;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import static java.lang.Math.sqrt;
public class HistoryData {
static String seasonTable = "_season";
static String unbalanceTable = "_ub";
static String minITable = "_minI";
static String seasonClusterTable = "_seasonCluster";
static String psClusterTable = "_psCluster";
static String ubMaxTable = "_ubMax";
static String tfAvailCapTable = "_availCap";
static Map<String, Double> ratedIJK = new HashMap<String, Double>(){{
put("35", 150.);
put("50", 180.);
put("70", 225.);
put("95", 275.);
put("120", 320.);
put("150", 365.);
put("185", 420.);
put("240", 500.);
put("300", 580.);
}};
static Map<String, Double> ratedILGJ = new HashMap<String, Double>(){{
put("35", 170.);
put("50", 220.);
put("70", 275.);
put("95", 335.);
put("120", 380.);
put("150", 445.);
put("185", 515.);
put("240", 610.);
put("300", 754.);
}};
Complex a = new Complex(-1.0 / 2,sqrt(3) / 2);
Complex a2 = Complex.multiply(a, a);
Complex aThird = new Complex(1.0 / 3, 0);
/**
* 创建线路电流表格和按季度分析结果表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public static void createLineCurrentTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" date datetime NULL," +
" current decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
initSql = "CREATE TABLE " + tableName + seasonTable + " (" +
" season INTEGER NULL," +
" current decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + seasonTable;
sqliteDb.executeSql(sql);
}
/**
* 创建公变数据表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public static void createTFTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName varchar(50) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" date datetime NULL," +
" Ia decimal(8,4) NULL, " +
" Ib decimal(8,4) NULL, " +
" Ic decimal(8,4) NULL, " +
" Ua decimal(8,4) NULL, " +
" Ub decimal(8,4) NULL, " +
" Uc decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
initSql = "CREATE TABLE " + tableName + seasonTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" P decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
// 公变三相不平衡度分析结果表，season=-1为年平均不平衡度
initSql = "CREATE TABLE " + tableName + unbalanceTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" ubI2 decimal(2,7) NULL, " +
" ubI0 decimal(2,7) NULL, " +
" ubV2 decimal(2,7) NULL, " +
" ubV0 decimal(2,7) NULL " +
")";
sqliteDb.initDb(initSql);
// 公变最小相电流分析结果表，season=-1为年平均最小电流
initSql = "CREATE TABLE " + tableName + minITable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" phase INTEGER NULL," +
" minI decimal(6,4) NULL " +
")";
sqliteDb.initDb(initSql);
// 公变三相不平衡度最大值表
initSql = "CREATE TABLE " + tableName + ubMaxTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" ubI2 decimal(2,7) NULL, " +
" ubV2 decimal(2,7) NULL " +
")";
sqliteDb.initDb(initSql);
// 公变按季节聚类结果表
initSql = "CREATE TABLE " + tableName + seasonClusterTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" P decimal(2,7) NULL, " +
" ubI2 decimal(2,7) NULL " +
")";
sqliteDb.initDb(initSql);
// 公变按峰谷聚类结果表
initSql = "CREATE TABLE " + tableName + psClusterTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" P decimal(2,7) NULL, " +
" ubI2 decimal(2,7) NULL " +
")";
sqliteDb.initDb(initSql);
// 公变可开放容量结果表
initSql = "CREATE TABLE " + tableName + tfAvailCapTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" availCap decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + seasonTable;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + unbalanceTable;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + minITable;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + ubMaxTable;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + seasonClusterTable;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + psClusterTable;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + tfAvailCapTable;
sqliteDb.executeSql(sql);
}
/**
* 创建公变月三相不平衡度表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public static void createTfMonthUbTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName varchar(200) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" lineName varchar(200) NOT NULL," +
" lineMRID varchar(50) NOT NULL," +
" substation varchar(20) NOT NULL," +
" maxLoad decimal(8,4) NULL," +
" ratedCap decimal(4,0) NULL," +
" ub decimal(2,7) NULL, " +
" monthUb1 decimal(2,7) NULL, " +
" monthUb2 decimal(2,7) NULL, " +
" monthUb3 decimal(2,7) NULL, " +
" monthUb4 decimal(2,7) NULL, " +
" monthUb5 decimal(2,7) NULL, " +
" monthUb6 decimal(2,7) NULL, " +
" monthUb7 decimal(2,7) NULL, " +
" monthUb8 decimal(2,7) NULL, " +
" monthUb9 decimal(2,7) NULL, " +
" monthUb10 decimal(2,7) NULL, " +
" monthUb11 decimal(2,7) NULL, " +
" monthUb12 decimal(2,7) NULL, " +
" monthUb13 decimal(2,7) NULL, " +
" monthUb14 decimal(2,7) NULL, " +
" monthUb15 decimal(2,7) NULL, " +
" monthUb16 decimal(2,7) NULL, " +
" monthUb17 decimal(2,7) NULL, " +
" monthUb18 decimal(2,7) NULL, " +
" monthUb19 decimal(2,7) NULL, " +
" monthUb20 decimal(2,7) NULL, " +
" monthUb21 decimal(2,7) NULL, " +
" monthUb22 decimal(2,7) NULL, " +
" monthUb23 decimal(2,7) NULL, " +
" monthUb24 decimal(2,7) NULL, " +
" monthUb25 decimal(2,7) NULL, " +
" monthUb26 decimal(2,7) NULL, " +
" monthUb27 decimal(2,7) NULL, " +
" monthUb28 decimal(2,7) NULL, " +
" monthUb29 decimal(2,7) NULL, " +
" monthUb30 decimal(2,7) NULL, " +
" monthUb31 decimal(2,7) NULL " +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建公变参数表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public static void createTFParamTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName varchar(50) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" blLine varchar(50) NOT NULL," +
" ratedCap decimal(4,0) NULL " +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建智能开关数据表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public static void createSwitchTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName varchar(50) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" date datetime NULL," +
" Ia decimal(8,4) NULL, " +
" Ib decimal(8,4) NULL, " +
" Ic decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
initSql = "CREATE TABLE " + tableName + seasonTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" Ia decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
initSql = "CREATE TABLE " + tableName + seasonClusterTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" Ia decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
initSql = "CREATE TABLE " + tableName + psClusterTable + " (" +
" mRID varchar(50) NOT NULL," +
" season INTEGER NULL," +
" Ia decimal(8,4) NULL " +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + seasonTable;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + seasonClusterTable;
sqliteDb.executeSql(sql);
sql = "delete from " + tableName + psClusterTable;
sqliteDb.executeSql(sql);
}
/**
* 创建线路参数表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public static void createLineParamTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" devName varchar(200) NOT NULL," +
" pole1 varchar(100) NOT NULL," +
" pole2 varchar(100) NOT NULL," +
" ratedCurrent decimal(6,2) NULL, " +
" type INTEGER NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建馈线名称表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createFeederNameTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" feeder varchar(200) NOT NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 存储馈线名称
*/
public void saveFeederName(String feederNameTable, String dbFile, String feederName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + feederNameTable + " values('" + feederName + "')";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
/**
* 创建线路合格率表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createLinePassRateTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" feederName varchar(200) NOT NULL," +
" substation varchar(20) NOT NULL," +
" passRate1 decimal(1,6) NULL," +
" passRate2 decimal(1,6) NULL," +
" passRate3 decimal(1,6) NULL," +
" passRate4 decimal(1,6) NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 创建公变越限表格
* @param dbFile 数据库路径
* @param tableName 表名
*/
public void createTfOverLoadTable(String dbFile, String tableName) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
String initSql = "CREATE TABLE " + tableName + " (" +
" feederName varchar(200) NOT NULL," +
" devName varchar(200) NOT NULL," +
" mRID varchar(50) NOT NULL," +
" lineName varchar(200) NOT NULL," +
" lineMRID varchar(50) NOT NULL," +
" substation varchar(20) NOT NULL," +
" overLoadRate1 decimal(1,6) NULL," +
" overLoadRate2 decimal(1,6) NULL," +
" overLoadRate3 decimal(1,6) NULL," +
" overLoadRate4 decimal(1,6) NULL" +
")";
sqliteDb.initDb(initSql);
// 清空表格
String sql = "delete from " + tableName;
sqliteDb.executeSql(sql);
}
/**
* 解析线路电流文件并存库
* @param tableName 表名
* @param filesPath 文件路径
* @param dbFile 数据库路径
*/
public static void parseLineCurrent(String tableName, String filesPath, String dbFile) {
// 获取所有txt文件路径
LinkedList<String> filePathList = new LinkedList<>();
File[] fileList = new File(filesPath).listFiles();
for(File file : fileList) {
if(file.isFile()) {
if (file.getName().endsWith(".txt")) {
filePathList.add(filesPath + "\\" + file.getName());
}
}
}
// 逐个解析文件
for (String filePath : filePathList) {
try {
parseLineCurrent(tableName, new FileInputStream(new File(filePath)), dbFile);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
public static void parseLineCurrent(String tableName, InputStream in, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(in, "GBK"));
List<String> sqls = new LinkedList<>();
String strLine = reader.readLine();
String[] lastContent = new String[]{"0", "0"};
while ((strLine = reader.readLine()) != null) {
String[] contents = strLine.split("\t");
if (contents.length == 1)
contents = new String[]{contents[0], lastContent[1]};
// 处理datetime数据
DateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //创建一个格式化日期对象
Date date = null;
try {
date = simpleDateFormat.parse(contents[0]);
} catch (ParseException e) {
e.printStackTrace();
}
Timestamp timeStamp = new Timestamp(date.getTime()); // 让日期时间转换为数据库中的timestamp类型
String insertSql = "insert into " + tableName + " values(" +
"'" + timeStamp + "'," + contents[1] + ")";
sqls.add(insertSql);
lastContent = contents;
}
sqliteDb.executeSqls(sqls);
sqls.clear();
reader.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 解析公变参数文件并存库
* @param tableName 表名
* @param filePath 文件路径
* @param dbFile 数据库路径
*/
public static void parseTFParam(String tableName, String filePath, String dbFile) {
try {
InputStream in = new FileInputStream(new File(filePath));
SqliteDb sqliteDb = new SqliteDb(dbFile);
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
List<String> sqls = new LinkedList<>();
String strLine = reader.readLine();
reader.readLine();
while ((strLine = reader.readLine()) != null) {
String[] contents = strLine.split(",");
double ratedCap = 400;
String insertSql = "insert into " + tableName + " values(" +
"'" + contents[1] + "','" + "0" + "','" + contents[3] + "'," + contents[5] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
reader.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
/**
* 解析公变数据文件并存库
* @param tableName 表名
* @param filesPath 文件路径
* @param dbFile 数据库路径
*/
public static void parseTF(String tableName, String filesPath, String dbFile) {
// 获取所有txt文件路径
LinkedList<String> filePathList = new LinkedList<>();
File[] fileList = new File(filesPath).listFiles();
for(File file : fileList) {
if(file.isFile()) {
if (file.getName().endsWith(".txt")) {
filePathList.add(filesPath + "\\" + file.getName());
}
}
}
// 逐个解析文件
SqliteDb sqliteDb = new SqliteDb(dbFile);
for (String filePath : filePathList) {
List<String> sqls = new LinkedList<>();
String s = readJsonFile(filePath);
JSONObject jobj = JSON.parseObject(s);
String devName = (String)jobj.get("devName");
JSONArray tfs = jobj.getJSONArray("root"); //构建JSONArray数组
for (int i = 0; i < tfs.size(); i++) {
JSONObject tf = (JSONObject) tfs.get(i);
// 处理datetime数据
DateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //创建一个格式化日期对象
Date date = null;
try {
date = simpleDateFormat.parse((String)tf.get("SJSJ"));
} catch (ParseException e) {
e.printStackTrace();
}
Timestamp timeStamp = new Timestamp(date.getTime()); // 让日期时间转换为数据库中的timestamp类型
String insertSql = "insert into " + tableName + " values(" +
"'" + devName + "','" + (((String)tf.get("zybh")).replace('-','_')) + "','" +
timeStamp + "'," + tf.get("Ia") + "," + tf.get("Ib") + "," + tf.get("Ic") + "," +
tf.get("Ua") + "," + tf.get("Ub") + "," + tf.get("Uc") + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
/**
* 解析公变参数文件并存库
* @param tfParamTableName 公变参数表名
* @param tfTableName 公变表名
* @param dbFile 数据库路径
*/
public static void parseTFMRID(String tfParamTableName, String tfTableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
Map<String, String> nameToMRID = sqliteDb.queryNameToMRID(tfTableName);
List<String> sqls = new LinkedList<>();
for (String name : nameToMRID.keySet()) {
String updateSql = "update " + tfParamTableName + " set mRID = '" + nameToMRID.get(name) + "' where devName = '" + name + "'";
sqls.add(updateSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
/**
* 解析开关数据文件并存库
* @param tableName 表名
* @param filesPath 文件路径
* @param dbFile 数据库路径
*/
public static void parseSwitch(String tableName, String filesPath, String dbFile) {
// 获取所有txt文件路径
LinkedList<String> filePathList = new LinkedList<>();
File[] fileList = new File(filesPath).listFiles();
for(File file : fileList) {
if(file.isFile()) {
if (file.getName().endsWith(".txt")) {
filePathList.add(filesPath + "\\" + file.getName());
}
}
}
// 逐个解析文件
SqliteDb sqliteDb = new SqliteDb(dbFile);
for (String filePath : filePathList) {
List<String> sqls = new LinkedList<>();
String s = readJsonFile(filePath);
JSONObject jobj = JSON.parseObject(s);
String devName = (String)jobj.get("devName");
JSONArray sws = jobj.getJSONArray("root"); //构建JSONArray数组
for (int i = 0; i < sws.size(); i++) {
JSONObject sw = (JSONObject) sws.get(i);
// 处理datetime数据
DateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //创建一个格式化日期对象
Date date = null;
try {
date = simpleDateFormat.parse((String)sw.get("SJSJ"));
} catch (ParseException e) {
e.printStackTrace();
}
Timestamp timeStamp = new Timestamp(date.getTime()); // 让日期时间转换为数据库中的timestamp类型
String insertSql = "insert into " + tableName + " values(" +
"'" + devName + "','" + (((String)sw.get("zybh")).replace('-','_')) + "','" +
timeStamp + "'," + sw.get("Iax") + "," + sw.get("Ibx") + "," + sw.get("Icx") + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
//读取json文件
public static String readJsonFile(String fileName) {
String jsonStr = "";
try {
File jsonFile = new File(fileName);
FileReader fileReader = new FileReader(jsonFile);
Reader reader = new InputStreamReader(new FileInputStream(jsonFile),"utf-8");
int ch = 0;
StringBuffer sb = new StringBuffer();
while ((ch = reader.read()) != -1) {
sb.append((char) ch);
}
fileReader.close();
reader.close();
jsonStr = sb.toString();
return jsonStr;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
/**
* 解析线路参数文件并存库
* @param tableName 表名
* @param filePath 文件路径
* @param dbFile 数据库路径
*/
public static void parseLineParam(String tableName, String filePath, String dbFile) {
try {
InputStream in = new FileInputStream(new File(filePath));
SqliteDb sqliteDb = new SqliteDb(dbFile);
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
List<String> sqls = new LinkedList<>();
String strLine = reader.readLine();
while ((strLine = reader.readLine()) != null) {
String[] contents = strLine.split(",");
double ratedCurrent = 1000;
String[] type = contents[6].split("-");
int tp = 1;
if (type[0].startsWith("JKLYJ") || type[0].equals("JKLGYJ") || type[0].equals("JLYJ") || type[0].equals("JKYJ")) {
if (type.length == 3) {
if (ratedIJK.get(type[2]) != null) {
ratedCurrent = ratedIJK.get(type[2]);
}
} else if (type.length == 2) {
if (type[1].split("/").length > 1) {
if (ratedIJK.get(type[1].split("/")[1]) != null) {
ratedCurrent = ratedIJK.get(type[1].split("/")[1]);
}
} else {
if (ratedIJK.get(type[1]) != null) {
ratedCurrent = ratedIJK.get(type[1]);
}
}
}
} else if (type[0].startsWith("JL/")) {
if (type.length > 1) {
if (ratedIJK.get(type[1].split("/")[0]) != null) {
ratedCurrent = ratedIJK.get(type[1].split("/")[0]);
}
}
} else if (type[0].equals("LGJ")) {
tp = 2;
if (type.length > 1) {
if (ratedILGJ.get(type[1].split("/")[0]) != null) {
ratedCurrent = ratedILGJ.get(type[1].split("/")[0]);
}
}
} else {
System.out.println(contents[6]);
}
String insertSql = "insert into " + tableName + " values(" +
"'" + contents[0] + "','" + contents[7] + "','" + contents[8] + "'," + ratedCurrent + "," + tp + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
reader.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
/**
* 按季节处理线电流历史数据，每个时段电流取该季节的最大值
* @param tableName 表名
* @param dbFile 数据库路径
*/
public void lineCurrentDataAnalysis(String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
int T = 5; // 采点时间间隔
int pointNum = 24 * 60 / T;
for (int season = 1; season < 5; season++) {
double[] maxCurrent = new double[pointNum];
List<LineCurrentData> lineCurrentDatas = sqliteDb.queryLineCurrentData(tableName, season);
Iterator<LineCurrentData> iterator = lineCurrentDatas.iterator();
while (iterator.hasNext()) {
LineCurrentData lineCurrentData = iterator.next();
long time = lineCurrentData.getData().getTime();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
int tNum = (60 * hour + minutes) / T;
if (maxCurrent[tNum] < lineCurrentData.getCurrent())
maxCurrent[tNum] = lineCurrentData.getCurrent();
}
List<String> sqls = new LinkedList<>();
for (int i = 0; i < maxCurrent.length; i++) {
String insertSql = "insert into " + tableName + seasonTable + " values(" +
season + "," + maxCurrent[i] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
/**
* 按季节处理开关历史数据，每个时段电流取该季节的最大值
* @param tableName 表名
* @param dbFile 数据库路径
*/
public void switchDataAnalysis(String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
int T = 15; // 采点时间间隔
int pointNum = 24 * 60 / T;
List<String> mRIDs = sqliteDb.queryMRIds(tableName);
for (int i = 0; i < mRIDs.size(); i++) {
double yMaxI = 0;
double avgI = 0;
int count = 0;
for (int season = 1; season < 5; season++) {
double[] maxCurrent = new double[pointNum];
List<SwitchData> swDatas = sqliteDb.querySwitchData(tableName, mRIDs.get(i), season);
Iterator<SwitchData> iterator = swDatas.iterator();
while (iterator.hasNext()) {
SwitchData swData = iterator.next();
long time = swData.getData().getTime();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
int tNum = (60 * hour + minutes) / T;
if (maxCurrent[tNum] < swData.getIa())
maxCurrent[tNum] = swData.getIa();
if (yMaxI < swData.getIa())
yMaxI = swData.getIa();
avgI += swData.getIa();
count++;
}
List<String> sqls = new LinkedList<>();
for (int j = 0; j < pointNum; j++) {
String insertSql = "insert into " + tableName + seasonTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + maxCurrent[j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + tableName + seasonTable + " values(" +
"'" + mRIDs.get(i) + "'," + (-1) + "," + yMaxI + ")";
sqls.add(insertSql);
avgI /= count;
insertSql = "insert into " + tableName + seasonTable + " values(" +
"'" + mRIDs.get(i) + "'," + (-2) + "," + avgI + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
/**
* 按季节聚类开关历史数据
* @param tableName 表名
* @param dbFile 数据库路径
*/
public void switchDataSeasonCluster(String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
int T = 15; // 采点时间间隔
int pointNum = 24 * 60 / T;
List<String> mRIDs = sqliteDb.queryMRIds(tableName);
for (int i = 0; i < mRIDs.size(); i++) {
for (int season = 1; season < 5; season++) {
double[] center = new double[pointNum];
int[] count = new int[pointNum];
List<SwitchData> swDatas = sqliteDb.querySwitchData(tableName, mRIDs.get(i), season);
Iterator<SwitchData> iterator = swDatas.iterator();
while (iterator.hasNext()) {
SwitchData swData = iterator.next();
long time = swData.getData().getTime();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
int tNum = (60 * hour + minutes) / T;
center[tNum] += swData.getIa();
count[tNum]++;
}
for (int j = 0; j < pointNum; j++) {
if (count[j] > 0)
center[j] /= count[j];
}
List<String> sqls = new LinkedList<>();
for (int j = 0; j < pointNum; j++) {
String insertSql = "insert into " + tableName + seasonClusterTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + center[j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
}
/**
* 按峰谷聚类开关历史数据
* @param tableName 表名
* @param dbFile 数据库路径
*/
public void switchDataPsCluster(String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
int T = 15; // 采点时间间隔
int pointNum = 24 * 60 / T;
List<String> mRIDs = sqliteDb.queryMRIds(tableName);
for (int i = 0; i < mRIDs.size(); i++) {
for (int season = 1; season < 5; season++) {
double[] center = new double[pointNum];
int[] count = new int[pointNum];
for (int month = season * 3 - 2; month < season * 3 + 1; month++) {
List<SwitchData> swDatas = sqliteDb.querySwDataByMonth(tableName, mRIDs.get(i), month);
Iterator<SwitchData> iterator = swDatas.iterator();
while (iterator.hasNext()) {
SwitchData swData = iterator.next();
long time = swData.getData().getTime();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
int tNum = (60 * hour + minutes) / T;
center[tNum] += swData.getIa();
count[tNum]++;
}
boolean hasData = true;
for (int j = 0; j < pointNum; j++) {
if (count[j] == 0)
hasData = false;
}
if (hasData)
break;
}
for (int j = 0; j < pointNum; j++) {
if (count[j] > 0)
center[j] /= count[j];
}
List<String> sqls = new LinkedList<>();
for (int j = 0; j < pointNum; j++) {
String insertSql = "insert into " + tableName + psClusterTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + center[j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
}
/**
* 按季节处理公变历史数据，每个时段负荷取该季节的最大值，按季节和年计算平均三相不平衡度
* @param tableName 表名
* @param dbFile 数据库路径
*/
public void tfDataAnalysis(String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
int T = 15; // 采点时间间隔
int pointNum = 24 * 60 / T;
List<String> mRIDs = sqliteDb.queryMRIds(tableName);
for (int i = 0; i < mRIDs.size(); i++) {
double[][] mAvgUbI = new double[4][2]; // 季度平均三相电流不平衡度
double[][] mAvgUbV = new double[4][2]; // 季度平均三相电压不平衡度
double[][] mAvgI = new double[4][3]; // 季度平均三相电流
int[] mMinIPhase = new int[4];
double[] mMinI = new double[4];
double maxI = 0;
double avgI = 0;
int count = 0;
int seasonNum = 4; // 存在季度数据空缺的情况
double yMaxP = 0;
for (int season = 1; season < 5; season++) {
double[] maxP = new double[pointNum]; // 公变最大负荷
double[] maxUbI = new double[pointNum]; // 公变电流最大三相不平衡度
double[] maxUbV = new double[pointNum]; // 公变电压最大三相不平衡度
List<TFData> tfDatas = sqliteDb.queryTFData(tableName, mRIDs.get(i), season);
Iterator<TFData> iterator = tfDatas.iterator();
while (iterator.hasNext()) {
TFData tfData = iterator.next();
long time = tfData.getData().getTime();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
int tNum = (60 * hour + minutes) / T;
double P = tfData.getIa() * tfData.getUa() + tfData.getIb() * tfData.getUb() + tfData.getIc() * tfData.getUc();
if (maxP[tNum] < P)
maxP[tNum] = P;
if (yMaxP < P)
yMaxP = P;
if (maxI < tfData.getIa())
maxI = tfData.getIa();
if (maxI < tfData.getIb())
maxI = tfData.getIb();
if (maxI < tfData.getIc())
maxI = tfData.getIc();
avgI += tfData.getIa() + tfData.getIb() + tfData.getIc();
count += 3;
// 计算三相不平衡度
double[] ubI = unbalance(new Complex(tfData.getIa(), 0),
Complex.multiply(new Complex(tfData.getIb(), 0), a2),
Complex.multiply(new Complex(tfData.getIc(), 0), a));
mAvgUbI[season - 1][0] += ubI[0];
mAvgUbI[season - 1][1] += ubI[1];
double[] ubV = unbalance(new Complex(tfData.getUa(), 0),
Complex.multiply(new Complex(tfData.getUb(), 0), a2),
Complex.multiply(new Complex(tfData.getUc(), 0), a));
mAvgUbV[season - 1][0] += ubV[0];
mAvgUbV[season - 1][1] += ubV[1];
// 更新三相不平衡度最大值
if (maxUbI[tNum] < ubI[0])
maxUbI[tNum] = ubI[0];
if (maxUbV[tNum] < ubV[0])
maxUbV[tNum] = ubV[0];
// 计算季度平均三相电流
mAvgI[season - 1][0] += tfData.getIa();
mAvgI[season - 1][1] += tfData.getIb();
mAvgI[season - 1][2] += tfData.getIc();
}
if (tfDatas.size() == 0) {
seasonNum--;
} else {
mAvgUbI[season - 1][0] /= tfDatas.size();
mAvgUbI[season - 1][1] /= tfDatas.size();
mAvgUbV[season - 1][0] /= tfDatas.size();
mAvgUbV[season - 1][1] /= tfDatas.size();
mAvgI[season - 1][0] /= tfDatas.size();
mAvgI[season - 1][1] /= tfDatas.size();
mAvgI[season - 1][2] /= tfDatas.size();
// 分析季度平均电流最小相
mMinI[season - 1] = mAvgI[season - 1][0];
mMinIPhase[season - 1] = 0;
if (mMinI[season - 1] > mAvgI[season - 1][1]) {
mMinI[season - 1] = mAvgI[season - 1][1];
mMinIPhase[season - 1] = 1;
}
if (mMinI[season - 1] > mAvgI[season - 1][2]) {
mMinI[season - 1] = mAvgI[season - 1][2];
mMinIPhase[season - 1] = 2;
}
}
// 公变负荷数据存库
List<String> sqls = new LinkedList<>();
for (int j = 0; j < pointNum; j++) {
String insertSql = "insert into " + tableName + seasonTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + maxP[j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
// 最大三相不平衡度存库
for (int j = 0; j < pointNum; j++) {
String insertSql = "insert into " + tableName + ubMaxTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + maxUbI[j] + "," + maxUbV[j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
// 公变年最大负荷存库
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + tableName + seasonTable + " values(" +
"'" + mRIDs.get(i) + "'," + (-1) + "," + yMaxP + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
// 公变最大电流存库
insertSql = "insert into " + tableName + seasonTable + " values(" +
"'" + mRIDs.get(i) + "'," + (-2) + "," + maxI + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
// 公变平均电流存库
avgI /= count;
insertSql = "insert into " + tableName + seasonTable + " values(" +
"'" + mRIDs.get(i) + "'," + (-3) + "," + avgI + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
// 年平均三相不平衡度
double[] yAvgUbI = new double[2];
double[] yAvgUbV = new double[2];
for (int season = 0; season < 4; season++) {
yAvgUbI[0] += mAvgUbI[season][0];
yAvgUbI[1] += mAvgUbI[season][1];
yAvgUbV[0] += mAvgUbV[season][0];
yAvgUbV[1] += mAvgUbV[season][1];
}
yAvgUbI[0] /= seasonNum;
yAvgUbI[1] /= seasonNum;
yAvgUbV[0] /= seasonNum;
yAvgUbV[1] /= seasonNum;
// 三相不平衡度分析结果存库
sqls = new LinkedList<>();
for (int season = 1; season < 5; season++) {
insertSql = "insert into " + tableName + unbalanceTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + mAvgUbI[season - 1][0] + "," + mAvgUbI[season - 1][1] +
"," + mAvgUbV[season - 1][0] + "," + mAvgUbV[season - 1][1] + ")";
sqls.add(insertSql);
}
insertSql = "insert into " + tableName + unbalanceTable + " values(" +
"'" + mRIDs.get(i) + "'," + (-1) + "," + yAvgUbI[0] + "," + yAvgUbI[1] + "," + yAvgUbV[0] + "," + yAvgUbV[1] + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
// 计算年平均三相电流
double[] yAvgI = new double[3];
for (int season = 0; season < 4; season++) {
yAvgI[0] += mAvgI[season][0];
yAvgI[1] += mAvgI[season][1];
yAvgI[2] += mAvgI[season][2];
}
yAvgI[0] /= seasonNum;
yAvgI[1] /= seasonNum;
yAvgI[2] /= seasonNum;
// 分析年平均电流最小相
int yMinIPhase = 0;
double yMinI = yAvgI[0];
if (yMinI > yAvgI[1]) {
yMinI = yAvgI[1];
yMinIPhase = 1;
}
if (yMinI > yAvgI[2]) {
yMinI = yAvgI[2];
yMinIPhase = 2;
}
// 平均最小相电流分析结果存库
for (int season = 1; season < 5; season++) {
insertSql = "insert into " + tableName + minITable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + mMinIPhase[season - 1] + "," + mMinI[season - 1] + ")";
sqls.add(insertSql);
}
insertSql = "insert into " + tableName + minITable + " values(" +
"'" + mRIDs.get(i) + "'," + (-1) + "," + yMinIPhase + "," + yMinI + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
/**
* 公变月三相不平衡度
* @param tfTable 表名
* @param dbFile 数据库路径
*/
public void tfMonthUb(String tfTable, String dbFile, String tfMonthUbTable, String substationTable, String tfParamTable,
String tfSeasonTable, String tfToLineTable) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
// 查询变电站名称
String substation = sqliteDb.querySubstationName(substationTable);
Map<String, String> tfNameToMRID = sqliteDb.queryNameToMRID(tfTable);
for (String name : tfNameToMRID.keySet()) {
String mRID = tfNameToMRID.get(name);
for (int season = 1; season < 5; season++) {
double tfRatedCap = sqliteDb.queryTFCap(tfParamTable, mRID);
double tfMaxP = sqliteDb.queryMaxTFP(tfSeasonTable, mRID, -1) / 1000;
double ub = 0; // 年平均三相不平衡度
int ubCount = 0;
double[] monthUb = new double[31]; // 月三相不平衡度
int[] count = new int[31];
List<TFData> tfDatas = sqliteDb.queryTFData(tfTable, mRID, season);
Iterator<TFData> iterator = tfDatas.iterator();
while (iterator.hasNext()) {
TFData tfData = iterator.next();
long time = tfData.getData().getTime();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int day = calendar.get(Calendar.DAY_OF_MONTH);
// 计算三相不平衡度
double[] ubI = unbalance(new Complex(tfData.getIa(), 0),
Complex.multiply(new Complex(tfData.getIb(), 0), a2),
Complex.multiply(new Complex(tfData.getIc(), 0), a));
ub += ubI[0];
ubCount++;
monthUb[day - 1] += ubI[0];
count[day - 1]++;
}
ub /= ubCount;
for (int j = 0; j < 31; j++) {
if (count[j] > 0) {
monthUb[j] /= count[j];
}
}
// 公变对应的线路名称
List<String[]> lines = sqliteDb.querySwToDev(tfToLineTable, mRID);
if (lines.size() > 0) {
String[] line = lines.get(0);
// 公变月三相不平衡度存库
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + tfMonthUbTable + " values(" +
"'" + name + "','" + mRID + "','" + line[0] + "','" + line[1] + "','" + substation + "'," +
tfMaxP + "," + tfRatedCap + "," + ub + "," + monthUb[0] + "," + monthUb[1] + "," + monthUb[2] + "," +
monthUb[3] + "," + monthUb[4] + "," + monthUb[5] + "," + monthUb[6] + "," + monthUb[7] + "," +
monthUb[8] + "," + monthUb[9] + "," + monthUb[10] + "," + monthUb[11] + "," + monthUb[12] + "," +
monthUb[13] + "," + monthUb[14] + "," + monthUb[15] + "," + monthUb[16] + "," + monthUb[17] + "," +
monthUb[18] + "," + monthUb[19] + "," + monthUb[20] + "," + monthUb[21] + "," + monthUb[22] + "," +
monthUb[23] + "," + monthUb[24] + "," + monthUb[25] + "," + monthUb[26] + "," + monthUb[27] + "," +
monthUb[28] + "," + monthUb[29] + "," + monthUb[30] + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
}
}
/**
* 按季节聚类公变负荷历史数据和三相最大不平衡度
* @param tableName 表名
* @param dbFile 数据库路径
*/
public void tfDataSeasonCluster(String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
int T = 15; // 采点时间间隔
int pointNum = 24 * 60 / T;
List<String> mRIDs = sqliteDb.queryMRIds(tableName);
for (int i = 0; i < mRIDs.size(); i++) {
int seasonNum = 4; // 存在季度数据空缺的情况
for (int season = 1; season < 5; season++) {
double[] centerP = new double[pointNum]; // 负荷聚类中心
double[] centerUb = new double[pointNum]; // 不平衡度聚类中心
int[] count = new int[pointNum];
List<TFData> tfDatas = sqliteDb.queryTFData(tableName, mRIDs.get(i), season);
Iterator<TFData> iterator = tfDatas.iterator();
while (iterator.hasNext()) {
TFData tfData = iterator.next();
long time = tfData.getData().getTime();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
int tNum = (60 * hour + minutes) / T;
double P = tfData.getIa() * tfData.getUa() + tfData.getIb() * tfData.getUb() + tfData.getIc() * tfData.getUc();
centerP[tNum] += P;
// 计算三相不平衡度
double[] ubI = unbalance(new Complex(tfData.getIa(), 0),
Complex.multiply(new Complex(tfData.getIb(), 0), a2),
Complex.multiply(new Complex(tfData.getIc(), 0), a));
centerUb[tNum] += ubI[0];
count[tNum]++;
}
for (int j = 0; j < pointNum; j++) {
if (count[j] > 0) {
centerP[j] /= count[j];
centerUb[j] /= count[j];
}
}
// 公变按季节聚类结果存库
List<String> sqls = new LinkedList<>();
for (int j = 0; j < pointNum; j++) {
String insertSql = "insert into " + tableName + seasonClusterTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + centerP[j] + "," + centerUb[j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
}
/**
* 按峰谷聚类公变负荷历史数据和三相最大不平衡度
* @param tableName 表名
* @param dbFile 数据库路径
*/
public void tfDataPsCluster(String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
int T = 15; // 采点时间间隔
int pointNum = 24 * 60 / T;
List<String> mRIDs = sqliteDb.queryMRIds(tableName);
for (int i = 0; i < mRIDs.size(); i++) {
int seasonNum = 4; // 存在季度数据空缺的情况
for (int season = 1; season < 5; season++) {
double[] centerP = new double[pointNum]; // 负荷聚类中心
double[] centerUb = new double[pointNum]; // 不平衡度聚类中心
int[] count = new int[pointNum];
for (int month = season * 3 - 2; month < season * 3 + 1; month++) {
List<TFData> tfDatas = sqliteDb.queryTFDataByMonth(tableName, mRIDs.get(i), month);
Iterator<TFData> iterator = tfDatas.iterator();
while (iterator.hasNext()) {
TFData tfData = iterator.next();
long time = tfData.getData().getTime();
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
int tNum = (60 * hour + minutes) / T;
double P = tfData.getIa() * tfData.getUa() + tfData.getIb() * tfData.getUb() + tfData.getIc() * tfData.getUc();
centerP[tNum] += P;
// 计算三相不平衡度
double[] ubI = unbalance(new Complex(tfData.getIa(), 0),
Complex.multiply(new Complex(tfData.getIb(), 0), a2),
Complex.multiply(new Complex(tfData.getIc(), 0), a));
centerUb[tNum] += ubI[0];
count[tNum]++;
}
boolean hasData = true;
for (int j = 0; j < pointNum; j++) {
if (count[j] == 0)
hasData = false;
}
if (hasData)
break;
}
for (int j = 0; j < pointNum; j++) {
if (count[j] > 0) {
centerP[j] /= count[j];
centerUb[j] /= count[j];
}
}
// 公变按季节聚类结果存库
List<String> sqls = new LinkedList<>();
for (int j = 0; j < pointNum; j++) {
String insertSql = "insert into " + tableName + psClusterTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + centerP[j] + "," + centerUb[j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
}
/**
* 按季节计算公变可开放容量
* @param tableName 表名
* @param dbFile 数据库路径
*/
public void tfAvailCap(String tfSeasonTable, String tfParamTable, String tableName, String dbFile) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
int T = 15; // 采点时间间隔
int pointNum = 24 * 60 / T;
List<String> mRIDs = sqliteDb.queryMRIds(tfSeasonTable);
for (int i = 0; i < mRIDs.size(); i++) {
double tFRatedCap = sqliteDb.queryTFCap(tfParamTable, mRIDs.get(i));
for (int season = 1; season < 5; season++) {
double[] seasonP = sqliteDb.querySeasonTFP(tfSeasonTable, mRIDs.get(i), season, 96);
double[] availCap = new double[pointNum];
for (int j = 0; j < pointNum; j++) {
availCap[j] = tFRatedCap - seasonP[j] / 1000;
}
// 公变可接入容量存库
List<String> sqls = new LinkedList<>();
for (int j = 0; j < pointNum; j++) {
String insertSql = "insert into " + tableName + tfAvailCapTable + " values(" +
"'" + mRIDs.get(i) + "'," + season + "," + availCap[j] + ")";
sqls.add(insertSql);
}
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
}
/**
* 公变越限分析
*/
public void tfOverLoad(String dbFile, String feederTable, String substationTable, String tfOverLoadTable, String tfTable, String tfParamTable,
String tfSeasonTable, String tfToLineTable) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
// 查询馈线名称
String feeder = sqliteDb.queryFeederName(feederTable);
// 查询变电站名称
String substation = sqliteDb.querySubstationName(substationTable);
// 分析公变
Map<String, String> tfNameToMRID = sqliteDb.queryNameToMRID(tfTable);
List<String> sqls = new LinkedList<>();
for (String name : tfNameToMRID.keySet()) {
String mRID = tfNameToMRID.get(name);
double tfRatedCap = sqliteDb.queryTFCap(tfParamTable, mRID);
// 公变对应的线路名称
List<String[]> lines = sqliteDb.querySwToDev(tfToLineTable, mRID);
if (lines.size() > 0) {
String[] line = lines.get(0);
double[] overLoadRate = new double[4];
for (int season = 1; season < 5; season++) {
int count = 0;
List<TFData> tfDatas = sqliteDb.queryTFData(tfTable, mRID, season);
Iterator<TFData> iterator = tfDatas.iterator();
while (iterator.hasNext()) {
TFData tfData = iterator.next();
double P = tfData.getIa() * tfData.getUa() + tfData.getIb() * tfData.getUb() + tfData.getIc() * tfData.getUc();
double loadRate = P / tfRatedCap;
if (loadRate < 2 && loadRate > 1) {
overLoadRate[season - 1]++;
}
count++;
}
overLoadRate[season - 1] /= count;
}
String insertSql = "insert into " + tfOverLoadTable + " values(" +
"'" + feeder + "','" + name + "','" + mRID + "','" + line[0] + "','" + line[1] + "','" + substation + "'," +
overLoadRate[0] + "," + overLoadRate[1] + "," + overLoadRate[2] + "," + overLoadRate[3] + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
}
}
/**
* 四季线路电流合格率
*/
public void linePassRate(String dbFile, String feederTable, String substationTable, String swTable, String swToLineTable,
String oneLineParamTable, String linePassRateTable) {
SqliteDb sqliteDb = new SqliteDb(dbFile);
// 查询馈线名称
String feeder = sqliteDb.queryFeederName(feederTable);
// 查询变电站名称
String substation = sqliteDb.querySubstationName(substationTable);
// 分析线路（开关对应的线路）
Map<String, String> swNameToMRID = sqliteDb.queryNameToMRID(swTable);
double[] passRate = new double[4];
for (int season = 1; season < 5; season++) {
int count = 0;
for (String name : swNameToMRID.keySet()) {
String mRID = swNameToMRID.get(name);
List<String[]> lines = sqliteDb.querySwToDev(swToLineTable, mRID); // 开关对应的线路
List<SwitchData> swDatas = sqliteDb.querySwitchData(swTable, mRID, season);
Iterator<SwitchData> iterator = swDatas.iterator();
while (iterator.hasNext()) {
SwitchData swData = iterator.next();
double I = swData.getIa();
boolean pass = true;
for (String[] line : lines) {
double lineRatedI = sqliteDb.queryOneLineParam(oneLineParamTable, line[1]);
double loadRate = I / lineRatedI;
if (loadRate < 2 && loadRate > 1) {
pass = false;
break;
}
}
if (pass) {
passRate[season - 1]++;
}
count++;
}
}
passRate[season - 1] /= count;
}
List<String> sqls = new LinkedList<>();
String insertSql = "insert into " + linePassRateTable + " values(" +
"'" + feeder + "','" + substation + "'," + passRate[0] + "," + passRate[1] + "," + passRate[2] + "," + passRate[3] + ")";
sqls.add(insertSql);
sqliteDb.executeSqls(sqls);
sqls.clear();
}
/**
* 计算三相相量不平衡度
* @param Fa a相相量
* @param Fb b相相量
* @param Fc c相相量
* @return 负序和零序不平衡度
*/
public double[] unbalance(Complex Fa, Complex Fb, Complex Fc) {
// 处理三相量为0的情况
if (Fa.mod() + Fb.mod() + Fc.mod() < 1e-8)
return new double[]{0, 0};
double modFa1 = Complex.multiply(aThird, Complex.add(Complex.add(Fa, Complex.multiply(a, Fb)), Complex.multiply(a2, Fc))).mod();
double modFa2 = Complex.multiply(aThird, Complex.add(Complex.add(Fa, Complex.multiply(a2, Fb)), Complex.multiply(a, Fc))).mod();
double modFa0 = Complex.multiply(aThird, Complex.add(Complex.add(Fa, Fb), Fc)).mod();
return new double[]{modFa2 / modFa1, modFa0 / modFa1};
}
}
availCap/src/main/java/LineCurrentData.java 0 → 100644
import java.sql.Timestamp;
public class LineCurrentData {
Timestamp data;
double current;
public void setData(Timestamp data) {
this.data = data;
}
public Timestamp getData() {
return data;
}
public void setCurrent(double current) {
this.current = current;
}
public double getCurrent() {
return current;
}
}
availCap/src/main/java/LineParamData.java 0 → 100644
public class LineParamData {
String devName;
String pole1;
String pole2;
double ratedI;
int type; // 1为JK，2为LGJ
public void setDevName(String devName) {
this.devName = devName;
}
public String getDevName() {
return devName;
}
public void setPole1(String pole1) {
this.pole1 = pole1;
}
public String getPole1() {
return pole1;
}
public void setPole2(String pole2) {
this.pole2 = pole2;
}
public String getPole2() {
return pole2;
}
public void setRatedI(double ratedI) {
this.ratedI = ratedI;
}
public double getRatedI() {
return ratedI;
}
public void setType(int type) {
this.type = type;
}
public int getType() {
return type;
}
}
availCap/src/main/java/LinePassRate.java 0 → 100644
public class LinePassRate {
String feederName;
String substation;
double[] passRate;
public String getFeederName() {
return feederName;
}
public void setFeederName(String feederName) {
this.feederName = feederName;
}
public String getSubstation() {
return substation;
}
public void setSubstation(String substation) {
this.substation = substation;
}
public double[] getPassRate() {
return passRate;
}
public void setPassRate(double[] passRate) {
this.passRate = passRate;
}
}
availCap/src/main/java/LoadPos.java 0 → 100644
import java.util.ArrayList;
import java.util.List;
public class LoadPos {
double[] newLoad; // 接入的负荷
double[] newLoadI; // 接入负荷的电流
boolean[] canIn = new boolean[4];
double[][] swOrgLoad = new double[4][]; // 接入点开关原始负荷
double[][] swNewLoad = new double[4][96]; // 接入后开关电流
double[] swRateI = new double[4]; // 接入点开关限额
double[][] tfOrgLoad = new double[4][]; // 接入点公变原始负荷
double[][] tfNewLoad = new double[4][96]; // 接入后公变负荷
double[] tfRateCap = new double[4]; // 接入点公变额定容量
List<Integer> seasons = new ArrayList<>(4); // 季节
List<String> optEdges = new ArrayList<>(4); // 最优接入位置智能开关的mRID
List<String> optEdgeNames = new ArrayList<>(4); // 最优接入位置智能开关的名称
List<Double> seasonAvgCaps = new ArrayList<>(4); // 负荷接入后，线路剩余可接入容量（电流）的日平均值
List<Double> seasonMinCaps = new ArrayList<>(4); // 负荷接入后，线路剩余可接入容量（电流）的日最小值
List<Integer> seasons2 = new ArrayList<>(4);
List<String> optEdges2 = new ArrayList<>(4);
List<String> optEdgeNames2 = new ArrayList<>(4);
List<Double> seasonAvgCaps2 = new ArrayList<>(4);
List<Double> seasonMinCaps2 = new ArrayList<>(4);
String[] optTfs = new String[4]; // 最优接入位置公变的mRID
String[] optTfNames = new String[4]; // 最优接入位置公变的名称
String[] optPhase = new String[4]; // 公变接入相别
// season从0开始
public void calSwNewLoad(int season) {
for (int i = 0; i < 96; i++) {
swNewLoad[season][i] = newLoadI[i] + swOrgLoad[season][i];
}
}
public void calTfNewLoad(int season) {
for (int i = 0; i < 96; i++) {
tfNewLoad[season][i] = newLoad[i] + tfOrgLoad[season][i];
}
}
public void setSwOrgLoad(int season, double[] swOrgSeasonLoad) {
swOrgLoad[season] = swOrgSeasonLoad;
}
public void setSwNewLoad(int season, double[] swNewSeasonLoad) {
swNewLoad[season] = swNewSeasonLoad;
}
public void setTfOrgLoad(int season, double[] tfOrgSeasonLoad) {
tfOrgLoad[season] = tfOrgSeasonLoad;
}
public void setTfNewLoad(int season, double[] tfNewSeasonLoad) {
tfNewLoad[season] = tfNewSeasonLoad;
}
public void setOptTf(int season, String optTf) {
}
public double[] getNewLoad() {
return newLoad;
}
public void setNewLoad(double[] newLoad) {
this.newLoad = newLoad;
}
public double[] getNewLoadI() {
return newLoadI;
}
public void setNewLoadI(double[] newLoadI) {
this.newLoadI = newLoadI;
}
public boolean[] getCanIn() {
return canIn;
}
public void setCanIn(boolean[] canIn) {
this.canIn = canIn;
}
public double[][] getSwOrgLoad() {
return swOrgLoad;
}
public void setSwOrgLoad(double[][] swOrgLoad) {
this.swOrgLoad = swOrgLoad;
}
public double[][] getSwNewLoad() {
return swNewLoad;
}
public void setSwNewLoad(double[][] swNewLoad) {
this.swNewLoad = swNewLoad;
}
public double[] getSwRateI() {
return swRateI;
}
public void setSwRateI(double[] swRateI) {
this.swRateI = swRateI;
}
public double[][] getTfOrgLoad() {
return tfOrgLoad;
}
public void setTfOrgLoad(double[][] tfOrgLoad) {
this.tfOrgLoad = tfOrgLoad;
}
public double[][] getTfNewLoad() {
return tfNewLoad;
}
public void setTfNewLoad(double[][] tfNewLoad) {
this.tfNewLoad = tfNewLoad;
}
public double[] getTfRateCap() {
return tfRateCap;
}
public void setTfRateCap(double[] tfRateCap) {
this.tfRateCap = tfRateCap;
}
public void addLoadPos(int season, String optEdge, String optEdgeName, double seasonAvgCap, double seasonMinCap) {
this.seasons.add(season);
this.optEdges.add(optEdge);
this.optEdgeNames.add(optEdgeName);
this.seasonAvgCaps.add(seasonAvgCap);
this.seasonMinCaps.add(seasonMinCap);
}
public void addLoadPos2(int season, String optEdge, String optEdgeName, double seasonAvgCap, double seasonMinCap) {
this.seasons2.add(season);
this.optEdges2.add(optEdge);
this.optEdgeNames2.add(optEdgeName);
this.seasonAvgCaps2.add(seasonAvgCap);
this.seasonMinCaps2.add(seasonMinCap);
}
public List<Integer> getSeasons() {
return seasons;
}
public void setSeasons(List<Integer> seasons) {
this.seasons = seasons;
}
public List<String> getOptEdges() {
return optEdges;
}
public void setOptEdges(List<String> optEdges) {
this.optEdges = optEdges;
}
public List<String> getOptEdgeNames() {
return optEdgeNames;
}
public void setOptEdgeNames(List<String> optEdgeNames) {
this.optEdgeNames = optEdgeNames;
}
public List<Double> getSeasonAvgCaps() {
return seasonAvgCaps;
}
public void setSeasonAvgCaps(List<Double> seasonAvgCaps) {
this.seasonAvgCaps = seasonAvgCaps;
}
public List<Double> getSeasonMinCaps() {
return seasonMinCaps;
}
public void setSeasonMinCaps(List<Double> seasonMinCaps) {
this.seasonMinCaps = seasonMinCaps;
}
public List<Integer> getSeasons2() {
return seasons2;
}
public void setSeasons2(List<Integer> seasons2) {
this.seasons2 = seasons2;
}
public List<String> getOptEdges2() {
return optEdges2;
}
public void setOptEdges2(List<String> optEdges2) {
this.optEdges2 = optEdges2;
}
public List<String> getOptEdgeNames2() {
return optEdgeNames2;
}
public void setOptEdgeNames2(List<String> optEdgeNames2) {
this.optEdgeNames2 = optEdgeNames2;
}
public List<Double> getSeasonAvgCaps2() {
return seasonAvgCaps2;
}
public void setSeasonAvgCaps2(List<Double> seasonAvgCaps2) {
this.seasonAvgCaps2 = seasonAvgCaps2;
}
public List<Double> getSeasonMinCaps2() {
return seasonMinCaps2;
}
public void setSeasonMinCaps2(List<Double> seasonMinCaps2) {
this.seasonMinCaps2 = seasonMinCaps2;
}
public String[] getOptTfs() {
return optTfs;
}
public void setOptTfs(String[] optTfs) {
this.optTfs = optTfs;
}
public String[] getOptTfNames() {
return optTfNames;
}
public void setOptTfNames(String[] optTfNames) {
this.optTfNames = optTfNames;
}
public String[] getOptPhase() {
return optPhase;
}
public void setOptPhase(String[] optPhase) {
this.optPhase = optPhase;
}
}
availCap/src/main/java/LoadPosSeason.java 0 → 100644
public class LoadPosSeason {
int loadId;
String substation;
String feederName;
String canIn;
String tfName; // 最优接入位置公变的mRID
String tfMRID; // 最优接入位置公变的名称
String phase; // 公变接入相别
String time;
public int getLoadId() {
return loadId;
}
public void setLoadId(int loadId) {
this.loadId = loadId;
}
public String getSubstation() {
return substation;
}
public void setSubstation(String substation) {
this.substation = substation;
}
public String getFeederName() {
return feederName;
}
public void setFeederName(String feederName) {
this.feederName = feederName;
}
public String getCanIn() {
return canIn;
}
public void setCanIn(String canIn) {
this.canIn = canIn;
}
public String getTfName() {
return tfName;
}
public void setTfName(String tfName) {
this.tfName = tfName;
}
public String getTfMRID() {
return tfMRID;
}
public void setTfMRID(String tfMRID) {
this.tfMRID = tfMRID;
}
public String getPhase() {
return phase;
}
public void setPhase(String phase) {
this.phase = phase;
}
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
}
availCap/src/main/java/LoadPosSw.java 0 → 100644
public class LoadPosSw {
String canIn;
String swName;
String swMRID;
double[] newLoadI; // 接入的负荷电流
double[] swOrgLoad; // 接入点开关原始负荷
double[] swNewLoad; // 接入后开关电流
double[] swRateI; // 接入点开关限额
public String getCanIn() {
return canIn;
}
public void setCanIn(String canIn) {
this.canIn = canIn;
}
public String getSwName() {
return swName;
}
public void setSwName(String swName) {
this.swName = swName;
}
public String getSwMRID() {
return swMRID;
}
public void setSwMRID(String swMRID) {
this.swMRID = swMRID;
}
public double[] getNewLoadI() {
return newLoadI;
}
public void setNewLoadI(double[] newLoadI) {
this.newLoadI = newLoadI;
}
public double[] getSwOrgLoad() {
return swOrgLoad;
}
public void setSwOrgLoad(double[] swOrgLoad) {
this.swOrgLoad = swOrgLoad;
}
public double[] getSwNewLoad() {
return swNewLoad;
}
public void setSwNewLoad(double[] swNewLoad) {
this.swNewLoad = swNewLoad;
}
public double[] getSwRateI() {
return swRateI;
}
public void setSwRateI(double[] swRateI) {
this.swRateI = swRateI;
}
}
availCap/src/main/java/LoadPosTf.java 0 → 100644
public class LoadPosTf {
String canIn;
String tfName; // 最优接入位置公变的mRID
String tfMRID; // 最优接入位置公变的名称
String phase; // 公变接入相别
double[] newLoad; // 接入的负荷
double[] tfOrgLoad; // 接入点公变原始负荷
double[] tfNewLoad; // 接入后公变负荷
double[] tfRateCap; // 接入点公变额定容量
public String getCanIn() {
return canIn;
}
public void setCanIn(String canIn) {
this.canIn = canIn;
}
public String getTfName() {
return tfName;
}
public void setTfName(String tfName) {
this.tfName = tfName;
}
public String getTfMRID() {
return tfMRID;
}
public void setTfMRID(String tfMRID) {
this.tfMRID = tfMRID;
}
public String getPhase() {
return phase;
}
public void setPhase(String phase) {
this.phase = phase;
}
public double[] getNewLoad() {
return newLoad;
}
public void setNewLoad(double[] newLoad) {
this.newLoad = newLoad;
}
public double[] getTfOrgLoad() {
return tfOrgLoad;
}
public void setTfOrgLoad(double[] tfOrgLoad) {
this.tfOrgLoad = tfOrgLoad;
}
public double[] getTfNewLoad() {
return tfNewLoad;
}
public void setTfNewLoad(double[] tfNewLoad) {
this.tfNewLoad = tfNewLoad;
}
public double[] getTfRateCap() {
return tfRateCap;
}
public void setTfRateCap(double[] tfRateCap) {
this.tfRateCap = tfRateCap;
}
}
availCap/src/main/java/MaxMinAvailCap.java 0 → 100644
public class MaxMinAvailCap {
String feederName;
double availCap;
}
availCap/src/main/java/SqliteDb.java 0 → 100644
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.sql.*;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
public class SqliteDb {
String dbFile;
public SqliteDb(String dbFile) {
this.dbFile = dbFile;
}
private Connection createConn() {
File f = new File(dbFile);
if(!f.exists()) {
try {
f.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
Connection conn;
try {
Class.forName("org.sqlite.JDBC");
conn = DriverManager.getConnection("jdbc:sqlite:"+dbFile);
} catch (Exception e) {
StringWriter w = new StringWriter();
e.printStackTrace(new PrintWriter(w, true));
System.out.println("111"+e.getMessage());
return null;
}
return conn;
}
public Boolean executeSql(String sql) {
Connection conn = createConn();
if(conn == null) return false;
Statement stmt = null;
try {
conn.setAutoCommit(false);
stmt = conn.createStatement();
stmt.addBatch(sql);
stmt.executeBatch();
conn.commit();
} catch (SQLException e) {
try {
conn.rollback();
} catch (SQLException e1) {
System.out.println(e1.getMessage());
}
StringWriter w =new StringWriter();
e.printStackTrace(new PrintWriter(w, true));
System.out.println(e.getMessage());
return false;
} finally {
try {
stmt.close();
conn.setAutoCommit(true);
conn.close();
} catch (SQLException e) {
}
}
return true;
}
public Boolean executeSqls(List<String> sqls) {
Connection conn = createConn();
if(conn == null) return false;
Statement stmt = null;
try {
conn.setAutoCommit(false);
stmt = conn.createStatement();
for (String obj : sqls)
stmt.addBatch(obj);
stmt.executeBatch();
conn.commit();
} catch (SQLException e) {
try {
conn.rollback();
} catch (SQLException e1) {
System.out.println(e1.getMessage());
}
StringWriter w =new StringWriter();
e.printStackTrace(new PrintWriter(w, true));
System.out.println(e.getMessage());
return false;
} finally {
try {
stmt.close();
conn.setAutoCommit(true);
conn.close();
} catch (SQLException e) {
}
}
return true;
}
public void initDb(String initSql) {
Connection conn = createConn();
if (conn == null) {
System.out.println("Can't connect to sqlite !!!");
return;
}
Statement stmt= null;
try {
stmt = conn.createStatement();
stmt.executeUpdate(initSql);
} catch (SQLException e ) {
if (e.getMessage().contains("table $tableName already exists")) {
System.out.println("Table $tableName already exists");
} else {
StringWriter w = new StringWriter();
e.printStackTrace(new PrintWriter(w, true));
System.out.println(e.getMessage());
}
} finally {
try {
stmt.close();
conn.close();
} catch (SQLException e) {
}
}
}
public List<String> getTableNames() {
Connection conn = createConn();
String sql = "select name from sqlite_master where type='table'";
Statement stmt = null;
ResultSet rs = null;
List<String> tableNames = new LinkedList<>();
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
tableNames.add(rs.getString("name"));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return tableNames;
}
public boolean existTable(String table) {
Connection conn = createConn();
String sql = "select count(*) as tableNum from sqlite_master where type='table' and name='" + table + "'";
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
if (rs.getInt("tableNum") > 0)
return true;
else
return false;
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return false;
}
public List<String> queryMRIds(String tableName) {
List<String> mRIDs = new LinkedList<>();
Connection conn = createConn();
String sql = "select mRID from " + tableName + " group by mRId";
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
mRIDs.add(rs.getString("mRID"));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return mRIDs;
}
/**
* 查询开关对应的设备，或设备对应的开关，或公变对应的线路
* @param tableName
* @return
*/
public List<String[]> querySwToDev(String tableName, String mRID) {
List<String[]> mRIDNames = new LinkedList<>();
Connection conn = createConn();
String sql = "select devName2,mRID2 from " + tableName + " where mRID1='" + mRID + "'";
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
String[] mRIDName = new String[2];
mRIDName[0] = rs.getString("devName2");
mRIDName[1] = rs.getString("mRID2");
mRIDNames.add(mRIDName);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return mRIDNames;
}
public List<Object> queryData(String tableName, String psId) {
List<Object> objs = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName + " where psId='" + psId + "'";
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
Object obj = createObj(tableName, rs);
objs.add(obj);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return objs;
}
/**
* 查询变电站名称
* @param tableName 表名
* @return
*/
public String queryFeederName(String tableName) {
String feeder = null;
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
feeder = rs.getString("feeder");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return feeder;
}
/**
* 查询变电站名称
* @param tableName 表名
* @return
*/
public String querySubstationName(String tableName) {
String substation = null;
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
substation = rs.getString("substation");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return substation;
}
/**
* 按季节查询主线电流数据
* @param tableName 表名
* @param season 季节
* @return
*/
public List<LineCurrentData> queryLineCurrentData(String tableName, int season) {
List<LineCurrentData> lineCurrentDatas = new LinkedList<>();
Connection conn = createConn();
String sql;
if (season == 1)
sql = "select * from " + tableName + " where strftime('%m',date) >= '01' and strftime('%m',date) <= '03'";
else if (season == 2)
sql = "select * from " + tableName + " where strftime('%m',date) >= '04' and strftime('%m',date) <= '06'";
else if (season == 3)
sql = "select * from " + tableName + " where strftime('%m',date) >= '07' and strftime('%m',date) <= '09'";
else if (season == 4)
sql = "select * from " + tableName + " where strftime('%m',date) >= '10' and strftime('%m',date) <= '12'";
else
return lineCurrentDatas;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
LineCurrentData lineCurrentData = new LineCurrentData();
lineCurrentData.setData(rs.getTimestamp("date"));
lineCurrentData.setCurrent(rs.getDouble("current"));
lineCurrentDatas.add(lineCurrentData);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return lineCurrentDatas;
}
/**
* 按季节查询主线最大电流数据
* @param tableName 表名
* @param season 季节
* @param pointNum 一天的点数
* @return 一天的电流数据
*/
public double[] querySeasonLineI(String tableName, int season, int pointNum) {
double[] seasonLineI = new double[pointNum];
Connection conn = createConn();
String sql = "select * from " + tableName + " where season=" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
int count = 0;
while (rs.next() && count < pointNum) {
seasonLineI[count] = rs.getDouble("current");
count++;
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return seasonLineI;
}
/**
* 按mRID和季节查询开关数据
* @param tableName 表名
* @param mRID
* @param season 季节
* @return
*/
public List<SwitchData> querySwitchData(String tableName, String mRID, int season) {
List<SwitchData> swDatas = new LinkedList<>();
Connection conn = createConn();
String sql;
if (season == 1)
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) >= '01' and strftime('%m',date) <= '03'";
else if (season == 2)
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) >= '04' and strftime('%m',date) <= '06'";
else if (season == 3)
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) >= '07' and strftime('%m',date) <= '09'";
else if (season == 4)
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) >= '10' and strftime('%m',date) <= '12'";
else
return swDatas;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
SwitchData swData = new SwitchData();
swData.setDevName(rs.getString("devName"));
swData.setmRID(mRID);
swData.setData(rs.getTimestamp("date"));
swData.setIa(rs.getDouble("Ia"));
swData.setIb(rs.getDouble("Ib"));
swData.setIc(rs.getDouble("Ic"));
swDatas.add(swData);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return swDatas;
}
/**
* 按mRID和月份查询开关数据
* @param tableName 表名
* @param mRID
* @param month 月份
* @return
*/
public List<SwitchData> querySwDataByMonth(String tableName, String mRID, int month) {
List<SwitchData> swDatas = new LinkedList<>();
Connection conn = createConn();
String sql;
if (month >= 1 && month <= 12) {
String monthStr = String.format("%02d", month);
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) = '" + monthStr + "'";
} else
return swDatas;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
SwitchData swData = new SwitchData();
swData.setDevName(rs.getString("devName"));
swData.setmRID(mRID);
swData.setData(rs.getTimestamp("date"));
swData.setIa(rs.getDouble("Ia"));
swData.setIb(rs.getDouble("Ib"));
swData.setIc(rs.getDouble("Ic"));
swDatas.add(swData);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return swDatas;
}
/**
* 按mRID和季节查询开关最大电流或聚类结果
* @param tableName 表名
* @param mRID mRID
* @param season 季节
* @return
*/
public double[] querySeasonSwitchI(String tableName, String mRID, int season, int pointNum) {
double[] seasonSwI = new double[pointNum];
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "' and season =" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
int count = 0;
while (rs.next() && count < pointNum) {
seasonSwI[count] = rs.getDouble("Ia");
count++;
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt.close();
} catch (SQLException e) {
}
}
return seasonSwI;
}
/**
* 按mRID查询开关最大电流
* @param tableName 表名
* @param mRID mRID
* @return
*/
public double queryMaxSwitchI(String tableName, String mRID, int season) {
double maxSwI = 10;
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "' and season =" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
int count = 0;
while (rs.next()) {
maxSwI = rs.getDouble("Ia");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt.close();
} catch (SQLException e) {
}
}
return maxSwI;
}
/**
* 按mRID和季节查询公变数据
* @param tableName 表名
* @param mRID
* @param season 季节
* @return
*/
public List<TFData> queryTFData(String tableName, String mRID, int season) {
List<TFData> tfDatas = new LinkedList<>();
Connection conn = createConn();
String sql;
if (season == 1)
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) >= '01' and strftime('%m',date) <= '03'";
else if (season == 2)
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) >= '04' and strftime('%m',date) <= '06'";
else if (season == 3)
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) >= '07' and strftime('%m',date) <= '09'";
else if (season == 4)
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) >= '10' and strftime('%m',date) <= '12'";
else
return tfDatas;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
TFData tfData = new TFData();
tfData.setDevName(rs.getString("devName"));
tfData.setmRID(mRID);
tfData.setData(rs.getTimestamp("date"));
tfData.setIa(rs.getDouble("Ia"));
tfData.setIb(rs.getDouble("Ib"));
tfData.setIc(rs.getDouble("Ic"));
tfData.setUa(rs.getDouble("Ua"));
tfData.setUb(rs.getDouble("Ub"));
tfData.setUc(rs.getDouble("Uc"));
tfDatas.add(tfData);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return tfDatas;
}
/**
* 按mRID和月份查询公变数据
* @param tableName 表名
* @param mRID
* @param month 季节
* @return
*/
public List<TFData> queryTFDataByMonth(String tableName, String mRID, int month) {
List<TFData> tfDatas = new LinkedList<>();
Connection conn = createConn();
String sql;
if (month >= 1 && month <= 12) {
String monthStr = String.format("%02d", month);
sql = "select * from " + tableName + " where mRID='" + mRID + "' and strftime('%m',date) = '" + monthStr + "'";
} else
return tfDatas;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
TFData tfData = new TFData();
tfData.setDevName(rs.getString("devName"));
tfData.setmRID(mRID);
tfData.setData(rs.getTimestamp("date"));
tfData.setIa(rs.getDouble("Ia"));
tfData.setIb(rs.getDouble("Ib"));
tfData.setIc(rs.getDouble("Ic"));
tfData.setUa(rs.getDouble("Ua"));
tfData.setUb(rs.getDouble("Ub"));
tfData.setUc(rs.getDouble("Uc"));
tfDatas.add(tfData);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return tfDatas;
}
/**
* 按mRID查询公变最大负荷、最大电流
* @param tableName 表名
* @param mRID mRID
* @return
*/
public double queryMaxTFP(String tableName, String mRID, int season) {
double maxTFP = 50000;
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "' and season =" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
maxTFP = rs.getDouble("P");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt.close();
} catch (SQLException e) {
}
}
return maxTFP;
}
/**
* 按mRID查询公变三相不平衡度
* @param tableName 表名
* @param mRID mRID
* @param season 季节
* @return
*/
public double[] queryTFUb(String tableName, String mRID, int season) {
double[] ubIU = new double[2];
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "' and season =" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
ubIU[0] = rs.getDouble("ubI2");
ubIU[1] = rs.getDouble("ubV2");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt.close();
} catch (SQLException e) {
}
}
return ubIU;
}
/**
* 按mRID查询公变负荷接入相别
* @param tableName 表名
* @param mRID mRID
* @param season 季节
* @return
*/
public String queryMinIPhase(String tableName, String mRID, int season) {
int phaseInt = 0;
String phase = "a";
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "' and season =" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
phaseInt = rs.getInt("phase");
}
if (phaseInt == 1)
phase = "b";
if (phaseInt == 2)
phase = "c";
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt.close();
} catch (SQLException e) {
}
}
return phase;
}
/**
* 查询设备名称、mRID
* @param tableName 表名
* @return
*/
public Map<String, String> queryNameToMRID(String tableName) {
Map<String, String> nameToMRID = new HashMap<>();
Connection conn = createConn();
String sql = "select devName, mRID from " + tableName + " group by devName";
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
nameToMRID.put(rs.getString("devName"), rs.getString("mRID"));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return nameToMRID;
}
/**
* 查询公变容量
* @param tableName 表名
* @return
*/
public double queryTFCap(String tableName, String mRID) {
double cap = 400;
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "'";
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
cap = rs.getDouble("ratedCap");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return cap;
}
/**
* 按mRID和季节查询公变最大负荷或聚类结果
* @param tableName 表名
* @param mRID mRID
* @param season 季节
* @return
*/
public double[] querySeasonTFP(String tableName, String mRID, int season, int pointNum) {
double[] seasonSwI = new double[pointNum];
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "' and season =" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
int count = 0;
while (rs.next() && count < pointNum) {
seasonSwI[count] = rs.getDouble("P");
count++;
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt.close();
} catch (SQLException e) {
}
}
return seasonSwI;
}
/**
* 按mRID和季节查询公变最大三相不平衡度或聚类结果
* @param tableName 表名
* @param mRID mRID
* @param season 季节
* @return
*/
public double[] querySeasonTFUb(String tableName, String mRID, int season, int pointNum) {
double[] seasonSwI = new double[pointNum];
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "' and season =" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
int count = 0;
while (rs.next() && count < pointNum) {
seasonSwI[count] = rs.getDouble("ubI2");
count++;
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt.close();
} catch (SQLException e) {
}
}
return seasonSwI;
}
/**
* 查询线路电流限值
* @param tableName 表名
* @return
*/
public List<LineParamData> queryLineParam(String tableName) {
List<LineParamData> lineParamDatas = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
LineParamData lineParamData = new LineParamData();
lineParamData.setDevName(rs.getString("devName"));
lineParamData.setPole1(rs.getString("pole1"));
lineParamData.setPole2(rs.getString("pole2"));
lineParamData.setRatedI(rs.getDouble("ratedCurrent"));
lineParamData.setType(rs.getInt("type"));
lineParamDatas.add(lineParamData);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return lineParamDatas;
}
/**
* 查询单线电流限值
* @param tableName 表名
* @return
*/
public double queryOneLineParam(String tableName, String mRID) {
double oneLineParam = 1000;
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "'";
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
oneLineParam = rs.getDouble("ratedCurrent");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return oneLineParam;
}
/**
* 按mRID和季节查询开关或公变可接入容量
* @param tableName 表名
* @param mRID mRID
* @param season 季节
* @return
*/
public double[] queryAvailCap(String tableName, String mRID, int season, int pointNum) {
double[] availCap = new double[pointNum];
Connection conn = createConn();
String sql = "select * from " + tableName + " where mRID='" + mRID + "' and season =" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
int count = 0;
while (rs.next() && count < pointNum) {
availCap[count] = rs.getDouble("availCap");
count++;
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt.close();
} catch (SQLException e) {
}
}
return availCap;
}
/**
* 查询预警线路
* @param tableName 表名
* @return
*/
public List<WarnLine> queryWarnLine(String tableName) {
List<WarnLine> warnLines = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
WarnLine warnLine = new WarnLine();
warnLine.setLoadState(rs.getInt("loadState"));
warnLine.setDevName(rs.getString("devName"));
warnLine.setmRID(rs.getString("mRID"));
warnLine.setSubstation(rs.getString("substation"));
warnLine.setSwitchName(rs.getString("switchName"));
warnLine.setSwitchMRID(rs.getString("switchMRID"));
warnLine.setMaxI(rs.getDouble("maxI"));
warnLine.setRatedCurrent(rs.getDouble("ratedCurrent"));
warnLine.setLoadRate(rs.getDouble("loadRate"));
warnLines.add(warnLine);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return warnLines;
}
/**
* 查询按过载情况查询预警线路
* @param tableName 表名
* @return
*/
public List<WarnLine> queryWarnLine(String tableName, int loadState) {
List<WarnLine> warnLines = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName + " where loadState=" + loadState;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
WarnLine warnLine = new WarnLine();
warnLine.setLoadState(rs.getInt("loadState"));
warnLine.setDevName(rs.getString("devName"));
warnLine.setmRID(rs.getString("mRID"));
warnLine.setSubstation(rs.getString("substation"));
warnLine.setSwitchName(rs.getString("switchName"));
warnLine.setSwitchMRID(rs.getString("switchMRID"));
warnLine.setMaxI(rs.getDouble("maxI"));
warnLine.setRatedCurrent(rs.getDouble("ratedCurrent"));
warnLine.setLoadRate(rs.getDouble("loadRate"));
warnLines.add(warnLine);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return warnLines;
}
/**
* 查询预警公变
* @param tableName 表名
* @return
*/
public List<WarnTf> queryWarnTf(String tableName) {
List<WarnTf> warnTfs = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
WarnTf warnTf = new WarnTf();
warnTf.setLoadState(rs.getInt("loadState"));
warnTf.setDevName(rs.getString("devName"));
warnTf.setmRID(rs.getString("mRID"));
warnTf.setLineName(rs.getString("lineName"));
warnTf.setLineMRID(rs.getString("lineMRID"));
warnTf.setSubstation(rs.getString("substation"));
warnTf.setMaxLoad(rs.getDouble("maxLoad"));
warnTf.setRatedCap(rs.getDouble("ratedCap"));
warnTf.setLoadRate(rs.getDouble("loadRate"));
warnTfs.add(warnTf);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return warnTfs;
}
/**
* 查询预警公变
* @param tableName 表名
* @return
*/
public List<WarnTf> queryWarnTf(String tableName, int loadState) {
List<WarnTf> warnTfs = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName + " where loadState=" + loadState;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
WarnTf warnTf = new WarnTf();
warnTf.setLoadState(rs.getInt("loadState"));
warnTf.setDevName(rs.getString("devName"));
warnTf.setmRID(rs.getString("mRID"));
warnTf.setLineName(rs.getString("lineName"));
warnTf.setLineMRID(rs.getString("lineMRID"));
warnTf.setSubstation(rs.getString("substation"));
warnTf.setMaxLoad(rs.getDouble("maxLoad"));
warnTf.setRatedCap(rs.getDouble("ratedCap"));
warnTf.setLoadRate(rs.getDouble("loadRate"));
warnTfs.add(warnTf);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return warnTfs;
}
/**
* 查询公变月三相不平衡度
* @param tableName 表名
* @return
*/
public List<TfUb> queryTfMonthUb(String tableName) {
List<TfUb> tfUbs = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
TfUb tfUb = new TfUb();
tfUb.setDevName(rs.getString("devName"));
tfUb.setmRID(rs.getString("mRID"));
tfUb.setLineName(rs.getString("lineName"));
tfUb.setLineMRID(rs.getString("lineMRID"));
tfUb.setSubstation(rs.getString("substation"));
tfUb.setMaxLoad(rs.getDouble("maxLoad"));
tfUb.setRatedCap(rs.getDouble("ratedCap"));
tfUb.setUb(rs.getDouble("ub"));
double[] monthUb = new double[30];
for (int i = 0; i < 30; i++) {
monthUb[0] = rs.getDouble("monthUb" + (i + 1));
}
tfUb.setMonthUb(monthUb);
tfUbs.add(tfUb);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return tfUbs;
}
/**
* 查询线路合格率
* @param tableName 表名
* @return
*/
public List<LinePassRate> queryLinePassRate(String tableName) {
List<LinePassRate> linePassRates = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
LinePassRate linePassRate = new LinePassRate();
linePassRate.setFeederName(rs.getString("feederName"));
linePassRate.setSubstation(rs.getString("substation"));
double[] passRate = new double[4];
passRate[0] = rs.getDouble("passRate1");
passRate[1] = rs.getDouble("passRate2");
passRate[2] = rs.getDouble("passRate3");
passRate[3] = rs.getDouble("passRate4");
linePassRate.setPassRate(passRate);
linePassRates.add(linePassRate);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return linePassRates;
}
/**
* 查询公变越限率
* @param tableName 表名
* @return
*/
public List<TfOverLoadRate> queryTfOverLoadRate(String tableName) {
List<TfOverLoadRate> tfOverLoadRates = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
TfOverLoadRate tfOverLoadRate = new TfOverLoadRate();
tfOverLoadRate.setFeederName(rs.getString("feederName"));
tfOverLoadRate.setDevName(rs.getString("devName"));
tfOverLoadRate.setmRID(rs.getString("mRID"));
tfOverLoadRate.setLineName(rs.getString("lineName"));
tfOverLoadRate.setLineMRID(rs.getString("lineMRID"));
tfOverLoadRate.setSubstation(rs.getString("substation"));
double[] overLoadRate = new double[4];
overLoadRate[0] = rs.getDouble("overLoadRate1");
overLoadRate[1] = rs.getDouble("overLoadRate2");
overLoadRate[2] = rs.getDouble("overLoadRate3");
overLoadRate[3] = rs.getDouble("overLoadRate4");
tfOverLoadRate.setOverLoadRate(overLoadRate);
tfOverLoadRates.add(tfOverLoadRate);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return tfOverLoadRates;
}
/**
* 按季节查询负荷接入分析结果总表
* @param tableName 表名
* @param season 季节
* @return
*/
public List<LoadPosSeason> queryLoadPosSeason(String tableName, int season) {
List<LoadPosSeason> loadPosSeasons = new LinkedList<>();
Connection conn = createConn();
String sql;
sql = "select * from " + tableName + " where season=" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
LoadPosSeason loadPosSeason = new LoadPosSeason();
loadPosSeason.setLoadId(rs.getInt("loadId"));
loadPosSeason.setSubstation(rs.getString("substation"));
loadPosSeason.setFeederName(rs.getString("feederName"));
loadPosSeason.setCanIn(rs.getString("canIn"));
loadPosSeason.setTfName(rs.getString("tfName"));
loadPosSeason.setTfMRID(rs.getString("tfMRID"));
loadPosSeason.setPhase(rs.getString("phase"));
loadPosSeason.setTime(rs.getString("time"));
loadPosSeasons.add(loadPosSeason);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return loadPosSeasons;
}
/**
* 查询负荷接入分析结果总表中最大负荷Id
* @param tableName 表名
* @return
*/
public int queryMaxLoadId(String tableName) {
int maxLoadId = 0;
Connection conn = createConn();
String sql;
sql = "select max(loadId) as maxLoadId from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
maxLoadId = rs.getInt("maxLoadId");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return maxLoadId;
}
/**
* 按loadId和季节查询负荷接入开关分析结果
* @param tableName 表名
* @param loadId
* @param season 季节
* @return
*/
public LoadPosSw queryLoadPosSw(String tableName, int loadId, int season) {
LoadPosSw loadPosSw = new LoadPosSw();
Connection conn = createConn();
String sql;
sql = "select * from " + tableName + " where loadId='" + loadId + "' and season=" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
loadPosSw.setCanIn(rs.getString("canIn"));
loadPosSw.setSwName(rs.getString("swName"));
loadPosSw.setSwMRID(rs.getString("swMRID"));
double[] newLoadI = new double[96]; // 接入的负荷电流
double[] swOrgLoad = new double[96]; // 接入点开关原始负荷
double[] swNewLoad = new double[96]; // 接入后开关电流
double[] swRateI = new double[96]; // 接入点开关限额
String[] newLoadIStr = rs.getString("newLoadI").split(";");
String[] swOrgLoadStr = rs.getString("swOrgLoad").split(";");
String[] swNewLoadStr = rs.getString("swNewLoad").split(";");
double swRateIDouble = rs.getDouble("swRateI");
for (int i = 0; i < 96; i++) {
newLoadI[i] = Double.parseDouble(newLoadIStr[i]);
swOrgLoad[i] = Double.parseDouble(swOrgLoadStr[i]);
swNewLoad[i] = Double.parseDouble(swNewLoadStr[i]);
swRateI[i] = swRateIDouble;
}
loadPosSw.setNewLoadI(newLoadI);
loadPosSw.setSwOrgLoad(swOrgLoad);
loadPosSw.setSwNewLoad(swNewLoad);
loadPosSw.setSwRateI(swRateI);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return loadPosSw;
}
/**
* 按loadId和季节查询负荷接入公变分析结果
* @param tableName 表名
* @param loadId
* @param season 季节
* @return
*/
public LoadPosTf queryLoadPosTf(String tableName, int loadId, int season) {
LoadPosTf loadPosTf = new LoadPosTf();
Connection conn = createConn();
String sql;
sql = "select * from " + tableName + " where loadId='" + loadId + "' and season=" + season;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
loadPosTf.setCanIn(rs.getString("canIn"));
loadPosTf.setTfName(rs.getString("tfName"));
loadPosTf.setTfMRID(rs.getString("tfMRID"));
loadPosTf.setPhase(rs.getString("phase"));
double[] newLoad = new double[96]; // 接入的负荷电流
double[] tfOrgLoad = new double[96]; // 接入点开关原始负荷
double[] tfNewLoad = new double[96]; // 接入后开关电流
double[] tfRateCap = new double[96]; // 接入点开关限额
String[] newLoadStr = rs.getString("newLoad").split(";");
String[] tfOrgLoadStr = rs.getString("tfOrgLoad").split(";");
String[] tfNewLoadStr = rs.getString("tfNewLoad").split(";");
double tfRateCapDouble = rs.getDouble("tfRateCap");
for (int i = 0; i < 96; i++) {
newLoad[i] = Double.parseDouble(newLoadStr[i]);
tfOrgLoad[i] = Double.parseDouble(tfOrgLoadStr[i]);
tfNewLoad[i] = Double.parseDouble(tfNewLoadStr[i]);
tfRateCap[i] = tfRateCapDouble;
}
loadPosTf.setNewLoad(newLoad);
loadPosTf.setTfOrgLoad(tfOrgLoad);
loadPosTf.setTfNewLoad(tfNewLoad);
loadPosTf.setTfRateCap(tfRateCap);
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return loadPosTf;
}
/**
* 查询所有馈线名称
* @param tableName 表名
* @return
*/
public List<String> queryAllFeederName(String tableName) {
List<String> feederNames = new LinkedList<>();
Connection conn = createConn();
String sql = "select * from " + tableName;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
feederNames.add(rs.getString("feeder"));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return feederNames;
}
/**
* 按照过载类型和设备类型，查询预警设备数量
* @param tableName 表名
* @return
*/
public int queryWarnDevNum(String tableName, int loadState, int devType) {
int warnDevNum = 0;
Connection conn = createConn();
String sql = "select * from " + tableName + " where loadState='" + loadState + "' and type=" + devType;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
warnDevNum = rs.getInt("number");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return warnDevNum;
}
/**
* 查询可开放容量最大和最小两条线路
* @param tableName 表名
* @return
*/
public MaxMinAvailCap queryMaxMinAvailCap(String tableName, int maxOrMin) {
MaxMinAvailCap maxMinAvailCap = new MaxMinAvailCap();
Connection conn = createConn();
String sql = "select * from " + tableName + " where maxOrMin=" + maxOrMin;
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
maxMinAvailCap.feederName = rs.getString("feederName");
maxMinAvailCap.availCap = rs.getDouble("availCap");
}
} catch (SQLException e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException e) {
}
}
return maxMinAvailCap;
}
private Object createObj(String tableName, ResultSet rs) throws SQLException {
return null;
}
}
availCap/src/main/java/SwitchData.java 0 → 100644
import java.sql.Timestamp;
public class SwitchData {
String devName;
String mRID;
Timestamp data;
double Ia;
double Ib;
double Ic;
public void setDevName(String devName) {
this.devName = devName;
}
public String getDevName() {
return devName;
}
public void setmRID(String mRID) {
this.mRID = mRID;
}
public String getmRID() {
return mRID;
}
public void setData(Timestamp data) {
this.data = data;
}
public Timestamp getData() {
return data;
}
public void setIa(double ia) {
Ia = ia;
}
public double getIa() {
return Ia;
}
public void setIb(double ib) {
Ib = ib;
}
public double getIb() {
return Ib;
}
public void setIc(double ic) {
Ic = ic;
}
public double getIc() {
return Ic;
}
}
availCap/src/main/java/TFData.java 0 → 100644
import java.sql.Timestamp;
public class TFData {
String devName;
String mRID;
Timestamp data;
double Ia;
double Ib;
double Ic;
double Ua;
double Ub;
double Uc;
public void setDevName(String devName) {
this.devName = devName;
}
public String getDevName() {
return devName;
}
public void setmRID(String mRID) {
this.mRID = mRID;
}
public String getmRID() {
return mRID;
}
public void setData(Timestamp data) {
this.data = data;
}
public Timestamp getData() {
return data;
}
public void setIa(double ia) {
Ia = ia;
}
public double getIa() {
return Ia;
}
public void setIb(double ib) {
Ib = ib;
}
public double getIb() {
return Ib;
}
public void setIc(double ic) {
Ic = ic;
}
public double getIc() {
return Ic;
}
public void setUa(double ua) {
Ua = ua;
}
public double getUa() {
return Ua;
}
public void setUb(double ub) {
Ub = ub;
}
public double getUb() {
return Ub;
}
public void setUc(double uc) {
Uc = uc;
}
public double getUc() {
return Uc;
}
}
availCap/src/main/java/TfOverLoadRate.java 0 → 100644
public class TfOverLoadRate {
String feederName;
String devName;
String mRID;
String lineName;
String lineMRID;
String substation;
double[] overLoadRate;
public String getFeederName() {
return feederName;
}
public void setFeederName(String feederName) {
this.feederName = feederName;
}
public String getDevName() {
return devName;
}
public void setDevName(String devName) {
this.devName = devName;
}
public String getmRID() {
return mRID;
}
public void setmRID(String mRID) {
this.mRID = mRID;
}
public String getSubstation() {
return substation;
}
public void setSubstation(String substation) {
this.substation = substation;
}
public String getLineName() {
return lineName;
}
public void setLineName(String lineName) {
this.lineName = lineName;
}
public String getLineMRID() {
return lineMRID;
}
public void setLineMRID(String lineMRID) {
this.lineMRID = lineMRID;
}
public double[] getOverLoadRate() {
return overLoadRate;
}
public void setOverLoadRate(double[] overLoadRate) {
this.overLoadRate = overLoadRate;
}
}
availCap/src/main/java/TfUb.java 0 → 100644
public class TfUb {
int loadState;
String devName;
String mRID;
String lineName;
String lineMRID;
String substation;
double maxLoad;
double ratedCap;
double ub;
double[] monthUb;
public int getLoadState() {
return loadState;
}
public void setLoadState(int loadState) {
this.loadState = loadState;
}
public String getDevName() {
return devName;
}
public void setDevName(String devName) {
this.devName = devName;
}
public String getmRID() {
return mRID;
}
public void setmRID(String mRID) {
this.mRID = mRID;
}
public String getSubstation() {
return substation;
}
public void setSubstation(String substation) {
this.substation = substation;
}
public String getLineName() {
return lineName;
}
public void setLineName(String lineName) {
this.lineName = lineName;
}
public String getLineMRID() {
return lineMRID;
}
public void setLineMRID(String lineMRID) {
this.lineMRID = lineMRID;
}
public double getMaxLoad() {
return maxLoad;
}
public void setMaxLoad(double maxLoad) {
this.maxLoad = maxLoad;
}
public double getRatedCap() {
return ratedCap;
}
public void setRatedCap(double ratedCap) {
this.ratedCap = ratedCap;
}
public double getUb() {
return ub;
}
public void setUb(double ub) {
this.ub = ub;
}
public double[] getMonthUb() {
return monthUb;
}
public void setMonthUb(double[] monthUb) {
this.monthUb = monthUb;
}
}
availCap/src/main/java/WarnLine.java 0 → 100644
public class WarnLine {
int loadState;
String devName;
String mRID;
String substation;
String switchName;
String switchMRID;
double maxI;
double ratedCurrent;
double loadRate;
public int getLoadState() {
return loadState;
}
public void setLoadState(int loadState) {
this.loadState = loadState;
}
public String getDevName() {
return devName;
}
public void setDevName(String devName) {
this.devName = devName;
}
public String getmRID() {
return mRID;
}
public void setmRID(String mRID) {
this.mRID = mRID;
}
public String getSubstation() {
return substation;
}
public void setSubstation(String substation) {
this.substation = substation;
}
public String getSwitchName() {
return switchName;
}
public void setSwitchName(String switchName) {
this.switchName = switchName;
}
public String getSwitchMRID() {
return switchMRID;
}
public void setSwitchMRID(String switchMRID) {
this.switchMRID = switchMRID;
}
public double getMaxI() {
return maxI;
}
public void setMaxI(double maxI) {
this.maxI = maxI;
}
public double getRatedCurrent() {
return ratedCurrent;
}
public void setRatedCurrent(double ratedCurrent) {
this.ratedCurrent = ratedCurrent;
}
public double getLoadRate() {
return loadRate;
}
public void setLoadRate(double loadRate) {
this.loadRate = loadRate;
}
}
availCap/src/main/java/WarnTf.java 0 → 100644
public class WarnTf {
int loadState;
String devName;
String mRID;
String lineName;
String lineMRID;
String substation;
double maxLoad;
double ratedCap;
double loadRate;
public int getLoadState() {
return loadState;
}
public void setLoadState(int loadState) {
this.loadState = loadState;
}
public String getDevName() {
return devName;
}
public void setDevName(String devName) {
this.devName = devName;
}
public String getmRID() {
return mRID;
}
public void setmRID(String mRID) {
this.mRID = mRID;
}
public String getSubstation() {
return substation;
}
public void setSubstation(String substation) {
this.substation = substation;
}
public String getLineName() {
return lineName;
}
public void setLineName(String lineName) {
this.lineName = lineName;
}
public String getLineMRID() {
return lineMRID;
}
public void setLineMRID(String lineMRID) {
this.lineMRID = lineMRID;
}
public double getMaxLoad() {
return maxLoad;
}
public void setMaxLoad(double maxLoad) {
this.maxLoad = maxLoad;
}
public double getRatedCap() {
return ratedCap;
}
public void setRatedCap(double ratedCap) {
this.ratedCap = ratedCap;
}
public double getLoadRate() {
return loadRate;
}
public void setLoadRate(double loadRate) {
this.loadRate = loadRate;
}
}
availCap/src/main/kotlin/JyPowerSystem.kt 0 → 100644
import org.jgrapht.UndirectedGraph
import org.jgrapht.graph.SimpleGraph
import org.jgrapht.graph.Subgraph
import zju.devmodel.MapObject
import zju.dsmodel.DistriSys
import zju.dsmodel.DsDevices
import zju.dsmodel.DsModelCons
import zju.dsmodel.DsTopoNode
import zju.measure.DiscreteInfo
import zju.measure.MeasureInfo
import java.util.*
/**
* 缙云电网的cim文件有以下几个问题:
* 1. 没有TransformerWinding，而PowerTransformer被看成是ConductingEquipment，具有两个端子
* 2. 没有发电机,在判断是否是有源是通过是否有变压器设备代替
* 3. 电源点无法确定
* @date 2021/6/30.
*/
class JyPowerSystem(val sourceStationNames : Array<String>) : PowerSystem() {
var passed : Boolean = true
var errorId : String? = null
inner class JyMeasureProvider : MeasureProvider {
override fun getAnalogValue(measId: String, dataSource: String): Double? {
throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
}
override fun getDiscreteValue(measId: String, dataSource: String): Int? {
throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
}
override fun getAnalogsOfEquip(equip: String, dataSource: String): List<MeasureInfo> {
throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
}
override fun getDiscreteOfEquip(equip: String, dataSource: String): DiscreteInfo {
throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
}
override fun setResourceManager(resourceManager: PowerSystem) {
throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
}
override fun getSwitchStatus(switchId: String, dataSource: String): Boolean {
val dev = getResource(switchId)
val r = dev?.getProperty("NORMALOPEN")?.toBoolean()
if (r == null)
return true
else
return r
}
}
init {
this.measureProvider = JyMeasureProvider()
}
constructor() : this(emptyArray())
fun getNodeType(v: TN): Int {
var nodeType = DsTopoNode.TYPE_LINK
for (cn in v.cns) {
if (sourceCns.contains(cn))
return DsTopoNode.TYPE_SUB
val shuntEquips = getShuntEquips(cn)
if (!shuntEquips.isEmpty()) {
assert(shuntEquips.size == 1 && (shuntEquips[0].type == "ENERGYCONSUMER" || shuntEquips[0].type == "POWERTRANSFORMER"))
nodeType = DsTopoNode.TYPE_PQ
}
}
return nodeType
}
val simpledIslands = LinkedList<UndirectedGraph<TN, Edge>>()
val activeIslands = LinkedList<UndirectedGraph<String, Edge>>()
override fun filterDevices() {
try {
if (sourceCns.size == 0) {
// 搜索电源相关的CN
val substations = classToList["SUBSTATION"]?.filter { it.getProperty("NAME") != null && sourceStationNames.contains(it.getProperty("NAME").substringAfter("kV")) }
assert(substations?.size == sourceStationNames.size)
val substationIds = LinkedList<String>()
substations!!.forEach { substationIds.add(it.id) }
// val sourceBus = classToList["BUSBARSECTION"]?.filter { substationIds.contains(it.getProperty("MEMBEROF_EQUIPMENTCONTAINER")) }
val sourceBus = classToList["BUSBARSECTION"]?.filter { substationIds.contains(it.getProperty("EQUIPMENTCONTAINER")) }
sourceBus!!.forEach {
if (getTerminalsOfEquip(it).isEmpty()) {
passed = false
errorId = it.id
return
}
val cn = getCNOfTerminal(getTerminalsOfEquip(it)[0])!!.id
if (!sourceCns.contains(cn))
sourceCns.add(cn)
}
}
super.filterDevices()
} catch (e : Exception) {
e.printStackTrace()
return
}
}
override fun extraFilterDevices(graphes : MutableList<Subgraph<String, Edge, *>>) {
var aclineNum = 0
var switchNum = 0
var transformerNum = 0
var i = 1
for (g in graphes) {
var aclineNum2 = 0
var switchNum2 = 0
var transformerNum2 = 0
val cnInGraph = g.vertexSet().filterNot { it.endsWith(suffixOfAddedCn) }
cnInGraph.forEach { obj -> getTerminalsOfCN(getResource(obj)!!).map { getEquipOfTerminal(it) }.forEach {
if (it?.type == "ACLINESEGMENT") {
if (getTerminalsOfEquip(it!!).size == 1) {
aclineNum2 += 2
} else {
aclineNum2++
}
} else if (it?.type == "POWERTRANSFORMER") {
if (getTerminalsOfEquip(it!!).size == 1) {
transformerNum2 += 2
} else {
transformerNum2++
}
} else if (it != null && isSwitch(it)) {
if(getTerminalsOfEquip(it).size == 1) {
switchNum2 += 6
} else if(getTerminalsOfEquip(it).size == 3) {
switchNum2 += 2
} else {
switchNum2 += 3
}
}
}}
aclineNum2 /= 2
switchNum2 /= 6
transformerNum2 /= 2
aclineNum += aclineNum2
switchNum += switchNum2
transformerNum += transformerNum2
println("====================== " + i++ + " th island information =======================")
println("There are $aclineNum2 ac lines.")
println("There are $switchNum2 switches.")
println("There are $transformerNum2 transformers.")
}
aclines = HashMap<String, MapObject>(aclineNum)
switches = HashMap<String, MapObject>(switchNum)
transformers = HashMap<String, MapObject>(transformerNum)
for (g in graphes)
g.vertexSet().filterNot { it.endsWith(suffixOfAddedCn) }.forEach { cn -> getTerminalsOfCN(getResource(cn)!!)
.mapNotNull { getEquipOfTerminal(it) }
.forEach {
if(it.type == "ACLINESEGMENT") {
if (!aclines!!.containsKey(it.id))
aclines!!.put(it.id, it)
} else if(it.type == "POWERTRANSFORMER") {
if (!transformers!!.containsKey(it.id))
transformers!!.put(it.id, it)
} else if (isSwitch(it)) {
if (!switches!!.containsKey(it.id))
switches!!.put(it.id, it)
}
}
}
}
fun createActiveIslands() {
for (island in activeSubgraphes) {
val g = SimpleGraph<String, Edge>(Edge::class.java)
island.vertexSet().forEach {
g.addVertex(it)
}
island.edgeSet().forEach {
g.addEdge(island.getEdgeSource(it), island.getEdgeTarget(it), it)
}
activeIslands.add(g)
}
}
/**
* 生成计算模型
*/
fun createCalMode(): List<DistriSys> {
val result = ArrayList<DistriSys>(simpledIslands.size)
try {
var j = 1
// 网络简化之后的结果
for (island in simpledIslands) {
val devices = DsDevices()
devices.initialLists()
val vertexSet = island.vertexSet().toList()
for (i in 1..vertexSet.size) {
val v = vertexSet[i - 1]
if (getNodeType(v) == DsTopoNode.TYPE_PQ) {
v.id = "Load_$i" // 设置id
// 开始填充设备
val load = MapObject()
load.id = v.cns[0]
load.setProperty(DsModelCons.KEY_CONNECTED_NODE, v.id)
devices.spotLoads.add(load)
} else if (getNodeType(v) == DsTopoNode.TYPE_SUB) {
v.id = "SRC_$i" // 设置id
} else
v.id = "LINK_$i" // 设置id
}
// 处理边
island.edgeSet().forEach {
val tn1 = island.getEdgeSource(it)
val tn2 = island.getEdgeTarget(it)
// 支路只有开关类型
val sw = MapObject()
sw.id = tn1.id + "-" + tn2.id
sw.setProperty(DsModelCons.KEY_RESOURCE_TYPE, DsModelCons.RESOURCE_SWITCH)
sw.setProperty(DsModelCons.KEY_CONNECTED_NODE, tn1.id + ";" + tn2.id)
devices.switches.add(sw)
}
val r = DistriSys()
r.buildOrigTopo(devices)
result.add(r)
j++
}
} catch (e : Exception) {
e.printStackTrace()
}
return result
}
/**
* 简化网络
*/
fun doSimplification() {
try {
transformers!!.values.forEach { assert(getTerminalsOfEquip(it).size == 2) }
// origGraph.edgeSet().forEach {
// if(it.equips.size != 1)
// print("hh")
// assert(it.equips.size == 1)
// }
origGraph.edgeSet().forEach {
if (getResource(it.equips[0]) != null)
assert(isSwitch(getResource(it.equips[0])!!) || isConnEquip(getResource(it.equips[0])))
else
assert(isSwitch(getResource(it.equips[0].substring(0, it.equips[0].length - 3))!!))
}
for (island in activeSubgraphes) {
val cnToTN = HashMap<String, TN>(island.vertexSet().size)
val g = SimpleGraph<TN, Edge>(Edge::class.java)
island.vertexSet().forEach {
val tn = TN()
tn.cns.add(it)
cnToTN[it] = tn
g.addVertex(tn)
}
island.edgeSet().forEach {
val edge = Edge()
edge.equips.addAll(it.equips)
g.addEdge(cnToTN[island.getEdgeSource(it)], cnToTN[island.getEdgeTarget(it)], edge)
}
// todo: 去除没有电源的负荷
// 合并所有连在一起的AclineSegment
val feederEdges = g.edgeSet().filter { it.equips.all { isConnEquip(getResource(it)) } }
feederEdges.forEach {
if (g.edgeSet().contains(it)) {
val v1 = g.getEdgeSource(it)
val v2 = g.getEdgeTarget(it)
mergeTwoVertex(g, v1, v2)
}
}
//找出来开关对应的支路
// val switchEdges = g.edgeSet().filter {
// it.equips.size == 1 && (isSwitch(it.equips[0])
// || isSwitch(it.equips[0].substring(0, it.equips[0].length - 3)))
// }
// for (e in switchEdges) {
// if (!g.containsEdge(e))
// continue
// val v1 = g.getEdgeSource(e)
// val v2 = g.getEdgeTarget(e)
// if (v1 == null || v2 == null)
// continue
// g.removeEdge(e)
// val inspector = ConnectivityInspector(g)
// val graphs = inspector.connectedSets() //获得连通子图
// // 如果网络没有分裂
// if (graphs.size != 2) {
// g.addEdge(v1, v2, e)
// continue
// }
// // 网络分裂成两个, 下面两种情况需要处理
// // 1. 其中之一是无源的包含负荷的子网,合并节点
// // 2. 其中之一是无源的不包含负荷的子网,删除即可
// var needAdd = true
// for (subV in graphs) {
// var isNoSource = true
// var isNoLoad = true
// subV.map { getNodeType(it) }.forEach {
// if (it == DsTopoNode.TYPE_DG || it == DsTopoNode.TYPE_SUB) {
// isNoSource = false
// return@forEach
// } else if (it == DsTopoNode.TYPE_PQ) {
// isNoLoad = false
// }
// }
// if (isNoSource) {
// if (!isNoLoad) {//需要合并
// g.addEdge(v1, v2, e)
// mergeTwoVertex(g, v1, v2)
// needAdd = false
// break
// } else {//删除子图
//// subV.forEach { g.removeVertex(it) }
//// needAdd = false
//// break
// }
// }
// }
// if (needAdd)
// g.addEdge(v1, v2, e)
// }
// 删除只和两条支路连接的LinkNode
var isFinish = false
while (!isFinish) {
isFinish = true
val linkNodes = g.vertexSet().filter { getNodeType(it) == DsTopoNode.TYPE_LINK && g.edgesOf(it).size == 2 }
linkNodes.forEach {
val edges = g.edgesOf(it).toList()
val v1: TN
val v2: TN
v1 = if (g.getEdgeSource(edges[0]) == it)
g.getEdgeTarget(edges[0])
else
g.getEdgeSource(edges[0])
v2 = if (g.getEdgeSource(edges[1]) == it)
g.getEdgeTarget(edges[1])
else
g.getEdgeSource(edges[1])
g.removeVertex(it)
val edge = Edge()
// 将所有设备都与该边联系在一起
edge.equips.addAll(edges[0].equips)
edge.equips.addAll(edges[1].equips)
g.addEdge(v1, v2, edge)
isFinish = false
}
}
simpledIslands.add(g)
}
} catch (e : Exception) {
e.printStackTrace()
}
}
private fun mergeTwoVertex(g: SimpleGraph<TN, Edge>, v1: TN, v2: TN) {
val edgesOfV2 = g.edgesOf(v2).toList()
edgesOfV2.forEach {
val anotherV: TN = if (v2 == g.getEdgeSource(it)) {
g.getEdgeTarget(it)
} else
g.getEdgeSource(it)
g.removeEdge(it)
if (v1 == anotherV)
return@forEach
val e = g.getEdge(v1, anotherV)
if (e != null) {
if(it.equips.all { isConnEquip(getResource(it)) })
return@forEach
else
e.equips.addAll(it.equips)
} else
g.addEdge(v1, anotherV, it)
}
v1.cns.addAll(v2.cns)
g.removeVertex(v2)
}
override fun getShuntEquips(cn: MapObject): List<MapObject> {
val l = LinkedList<MapObject>()
getTerminalsOfCN(cn).forEach {
val equip = getEquipOfTerminal(it)
if (equip != null) {
if (shuntEquipTypes.contains(equip.type) || equip.type == "POWERTRANSFORMER")
l.add(equip)
}
}
return l
}
fun clearSimpledIslands() {
simpledIslands.clear()
}
fun isConnEquip(obj : MapObject?) : Boolean {
return obj?.type == "ACLINESEGMENT" || obj?.type == "CONNLINE" || obj?.type == "POWERTRANSFORMER"
}
}
availCap/src/main/kotlin/MeasureProvider.kt 0 → 100644
import zju.measure.DiscreteInfo
import zju.measure.MeasureInfo
/**
* 提供量测数据的接口
* @date 17-1-8.
*/
interface MeasureProvider {
fun getAnalogValue(measId: String, dataSource: String): Double?
fun getDiscreteValue(measId: String, dataSource: String): Int?
fun getAnalogsOfEquip(equip: String, dataSource: String): List<MeasureInfo>
fun getDiscreteOfEquip(equip: String, dataSource: String): DiscreteInfo?
fun setResourceManager(resourceManager: PowerSystem)
fun getSwitchStatus(switchId: String, dataSource: String): Boolean
}
\ No newline at end of file
availCap/src/main/kotlin/PowerSystem.kt 0 → 100644
import org.jgrapht.UndirectedGraph
import org.jgrapht.alg.ConnectivityInspector
import org.jgrapht.graph.SimpleGraph
import org.jgrapht.graph.Subgraph
import org.xml.sax.Attributes
import org.xml.sax.SAXException
import org.xml.sax.helpers.DefaultHandler
import zju.devmodel.MapObject
import zju.measure.MeasureInfo
import java.io.InputStream
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)
/**
* 该类用于管理电网资源(MapObject)的方法
* @date 17-1-8.
*/
open class PowerSystem {
companion object {
val switchTypes = arrayOf("BREAKER", "DISCONNECTOR", "FUSE", "GROUNDDISCONNECTOR", "COMPOSITESWITCH",
"JUMPER", "LOADBREAKSWITCH")
val conductingEquipTypes = arrayOf("ACLINESEGMENT", "TRANSFORMERWINDING", "BUSBARSECTION", "ENERGYCONSUMER",
"SYNCHRONOUSMACHINE", "SERIESCOMPENSATOR", "SHUNTCOMPENSATOR", "DCLINESEGMENT", "JUNCTION", "CONNLINE",
"POWERTRANSFORMER")
val shuntEquipTypes = arrayOf("ENERGYCONSUMER", "SYNCHRONOUSMACHINE", "SHUNTCOMPENSATOR")
val suffixOfAddedCn = "-neutral"
val minIslandSize = 5
}
val classToList = HashMap<String, MutableList<MapObject>>()
private var idToObject: MutableMap<String, MapObject> = HashMap()
// val assetIdToObject: MutableMap<String, MapObject> = HashMap()
val poleNameToCn: MutableMap<String, String> = HashMap()
// 主要的电力系统资源
var generators: MutableMap<String, MapObject>? = null
var loads: MutableMap<String, MapObject>? = null
var busbars: MutableMap<String, MapObject>? = null
var shuntCompensators: MutableMap<String, MapObject>? = null
var seriesCompensators: MutableMap<String, MapObject>? = null
var aclines: MutableMap<String, MapObject>? = null
var connlines: MutableMap<String, MapObject>? = null
var windings: MutableMap<String, MapObject>? = null
var switches: MutableMap<String, MapObject>? = null
var transformers: MutableMap<String, MapObject>? = null
// 需要的CN
var cns: MutableMap<String, MapObject>? = null
// 量测
var analogs: MutableMap<String, MapObject>? = null
var discretes: MutableMap<String, MapObject>? = null
var equipMeasurements: MutableMap<String, List<MeasureInfo>>? = null
//过滤量测和拓扑分析时需要用到该类
var measureProvider : MeasureProvider? = null
//量测来源
var dataSource = CimConstants.MEASURE_VALUE_SOURCE_SCADA
// 表明电力系统资源是否添加完毕,一旦完毕无法在添加
var isInitial = false
// 原始的有源拓扑岛
val origGraph = SimpleGraph<String, Edge>(Edge::class.java)
val activeSubgraphes: MutableList<Subgraph<String, Edge, *>> = LinkedList()
// 电源所在的ConnectivityNode
var sourceCns = LinkedList<String>()
fun getResourceByClassId(aClass: String): List<MapObject> {
classToList.putIfAbsent(aClass, ArrayList<MapObject>(0))
return classToList[aClass]!!
}
fun getResource(obj: String): MapObject? {
return idToObject[obj]
}
/**
* 从CIM XML中导入电网资源
*/
fun loadFromCimXML(input : InputStream) {
// step 1: 获得SAX解析器工厂实例
val factory = SAXParserFactory.newInstance()
// step 2: 获得SAX解析器实例
val parser = factory.newSAXParser()
// step 3: 开始进行解析
// 传入待解析的文档的处理器
parser.parse(input, CimXmlHandler())
}
/**
* 添加设备,所有设备添加结束之后应该调用endAddPSR方法
*/
fun addPSR(obj : MapObject) {
if(isInitial)
throw Exception("Power system is already initialed, new resource can not be added anymore.")
if(obj.id == null || obj.id.trim() == "") {
System.err.println("Illegal id of power system resource, id can not be null, this obj will not be added.")
System.err.println(obj.toString())
return
}
val isExist = idToObject.containsKey(obj.id)
if(!isExist) { // 同一个对象不能addPSR两次,否则这里添加不进去
idToObject.put(obj.id, obj)
if (obj.type == null || obj.type.trim() == "") {
print("!!No type is found for power system resource whose id is ${obj.id}")
return
}
if (!classToList.containsKey(obj.type))
classToList.put(obj.type, LinkedList<MapObject>())
classToList[obj.type]!!.add(obj)
// if (obj.getProperty("ASSETS") != null)
// assetIdToObject[obj.getProperty("ASSETS")] = obj
}
}
open fun endAddPSR() {
if(isInitial)
throw Exception("Power system is already initialed.")
isInitial = true
// 处理容器
idToObject.values.forEach {
val keys = it.properties.keys.filter { it.startsWith("MEMBEROF_") }
if(keys.size == 1) {
val r = idToObject[it.properties[keys[0]]]
if(r != null)
it.containerId = r.id
}
}
// 处理Terminal和ConnectivityNode之间的关系
val keys = arrayOf("CONDUCTINGEQUIPMENT","CONNECTIVITYNODE")
classToList["TERMINAL"]?.forEach {
// 处理1对多的关系
for(key in keys) {
val r = idToObject[it.properties[key]]
if (r != null) {
val s = r.properties[it.type]
if (s == null)
r.properties[it.type] = it.id
else
r.properties[it.type] = s + ";" + it.id
}
}
}
// 处理TransformerWinding与PowerTransformer之间的关系
classToList["TRANSFORMERWINDING"]?.forEach {
// 处理1对多的关系
val r = idToObject[it.properties["MEMBEROF_POWERTRANSFORMER"]]
if (r != null) {
val s = r.properties[it.type]
if (s == null)
r.properties[it.type] = it.id
else
r.properties[it.type] = s + ";" + it.id
}
}
// 结束之后开始过滤没有必要分析的设备
filterDevices()
}
private fun getObjectList(obj : MapObject, propertyName : String) : List<MapObject> {
val terminals = obj.properties[propertyName]
val l = LinkedList<MapObject>()
if(terminals != null) {
terminals.split(";").forEach {
val t = idToObject[it]
if(t != null)
l.add(t)
}
}
return l
}
fun getShuntEquips(cn : String) : List<MapObject> {
val node = getResource(cn)
if(node == null) return LinkedList()
else return getShuntEquips(node)
}
open fun getShuntEquips(cn : MapObject) : List<MapObject> {
val l = LinkedList<MapObject>()
getTerminalsOfCN(cn).forEach {
val equip = getEquipOfTerminal(it)
if(equip != null) {
if(shuntEquipTypes.contains(equip.type))
l.add(equip)
}
}
return l
}
fun getTerminalsOfEquip(obj : MapObject) : List<MapObject> {
return getObjectList(obj, "TERMINAL")
}
fun getCNOfTerminal(t: MapObject) : MapObject? {
val cnId = t.getProperty("CONNECTIVITYNODE")
if(cnId == null) {
println("!!No connectivy id of terminal ${t.id} is found.")
return null
} else
return getResource(cnId)
}
fun getTerminalsOfCN(cn : MapObject) : List<MapObject> {
return getObjectList(cn, "TERMINAL")
}
fun getEquipOfTerminal(t : MapObject) : MapObject? {
return getResource(t.getProperty("CONDUCTINGEQUIPMENT"))
}
fun getWindingsOfTf(transformer: MapObject) : List<MapObject> {
return getObjectList(transformer, "TRANSFORMERWINDING")
}
fun getTfOfWinding(winding : MapObject) : MapObject? {
return getResource(winding.getProperty("MEMBEROF_POWERTRANSFORMER"))
}
fun isSwitch(id : String) : Boolean {
val sw = getResource(id)
return sw != null && isSwitch(sw)
}
fun isSwitch(obj : MapObject) : Boolean {
return switchTypes.any { obj.type.toUpperCase() == it.toUpperCase() }
}
fun getAllSwitch() : List<MapObject> {
val r = LinkedList<MapObject>()
switchTypes.mapNotNull { classToList[it] }.forEach { r.addAll(it) }
return r
}
open fun getConductingEquips() : MutableList<MapObject> {
val r = LinkedList<MapObject>()
switchTypes.mapNotNull { classToList[it] }.forEach { r.addAll(it) }
conductingEquipTypes.mapNotNull { classToList[it] }.forEach { r.addAll(it) }
return r
}
fun isActiveCn(cn : String) : Boolean {
if(cn.endsWith(suffixOfAddedCn))
return false
getTerminalsOfCN(getResource(cn)!!)
// 判断是否是有电源的
.filter { getEquipOfTerminal(it)?.type == "SYNCHRONOUSMACHINE" }
.forEach { return true }
return false
}
fun isActive(subVertexes : Set<String>) : Boolean {
if(subVertexes.size < minIslandSize)
return false
@Suppress("LoopToCallChain")
for (cn in subVertexes) {
if(sourceCns.contains(cn))
return true
}
return false
}
open fun buildGraph() : MutableList<Subgraph<String, Edge, *>> {
try {
// 清空所有定点
origGraph.vertexSet().toList().forEach { origGraph.removeVertex(it) }
for (obj in getResourceByClassId("CONNECTIVITYNODE"))
origGraph.addVertex(obj.id)
for (obj in getConductingEquips()) {
val terminals = getTerminalsOfEquip(obj)
if (terminals.size != 2)
continue
if (isSwitch(obj) and (obj.getProperty("OPEN") == "true"))
continue
val cn1 = getCNOfTerminal(terminals[0])
val cn2 = getCNOfTerminal(terminals[1])
if (cn1 == null || cn2 == null || cn1.id == cn2.id)
continue
addEdge(cn1.id, cn2.id, obj.id, origGraph)
}
// 处理杆和cn的关系
for (obj in getResourceByClassId("POLECODE")) {
val terminals = getTerminalsOfEquip(obj)
if (terminals.size != 1)
continue
val cn = getCNOfTerminal(terminals[0]) ?: continue
if (obj.getProperty("NAME") != null)
poleNameToCn[obj.getProperty("NAME")] = cn.id
}
for (obj in getResourceByClassId("POWERTRANSFORMER")) {
val windings = getWindingsOfTf(obj)
if (windings.size < 2)
continue
val magneticCn = MapObject() // 中性点对应的CN
magneticCn.id = obj.id + suffixOfAddedCn
magneticCn.type = "CONNECTIVITYNODE"
origGraph.addVertex(magneticCn.id)
windings.forEach {
val cn = getCNOfTerminal(getTerminalsOfEquip(it)[0])
addEdge(magneticCn.id, cn!!.id, it.id, origGraph)
}
}
extraBuildGraph()
// 连通性分析
val inspector = ConnectivityInspector(origGraph)
val graphs = inspector.connectedSets() //获得连通子图
// 找出有电源的CN
graphs.forEach({
it.filter { isActiveCn(it) }.forEach({ sourceCns.add(it) })
})
// 找出有源的电气岛
graphs.filter { isActive(it) }
.mapTo(activeSubgraphes) { Subgraph<String, Edge, UndirectedGraph<String, Edge>>(origGraph, it) }
println("========== There are " + graphs.size + " islands totally. ============")
println("========== There are " + activeSubgraphes.size + " active islands. ============")
for (i in 1..activeSubgraphes.size) {
val vertexNum = activeSubgraphes[i - 1].vertexSet().size
val edgeNum = activeSubgraphes[i - 1].edgeSet().size
println("========== There are $vertexNum vertexes in sub island $i.============")
println("========== There are $edgeNum edges in sub island $i.============")
}
} catch (e: Exception) {
e.printStackTrace();
}
return activeSubgraphes
}
open fun extraBuildGraph() {}
fun addEdge(cn1: String, cn2: String, obj: String, g: SimpleGraph<String, Edge>) {
val e = g.getEdge(cn1, cn2)
if (e == null) {
val edge = Edge()
edge.equips.add(obj)
g.addEdge(cn1, cn2, edge)
} else
e.equips.add(obj)
}
/**
* 形成原始的拓扑图(node-brake),并过滤掉无源的拓扑岛
*/
open fun filterDevices() {
val graphs = buildGraph() //先分析原始的拓扑图
filterDevices(graphs)
}
open fun filterDevices(graphs: MutableList<Subgraph<String, Edge, *>>) {
// val graphs = activeSubgraphes //先分析原始的拓扑图
// 统计ConnectivityNode的数量
val cnNum = graphs.sumBy { it.vertexSet().size }
cns = HashMap(cnNum)
for(g in graphs)
g.vertexSet().forEach {
if(!it.endsWith(suffixOfAddedCn))
cns!!.put(it, getResource(it)!!)
}
var generatorNum = 0
var loadNum = 0
var busbarNum = 0
var shuntCompensatorNum = 0
var seriesCompensatorNum = 0
var aclineNum = 0
var connlineNum = 0
var windingNum = 0
var switchNum = 0
var i = 1
for (g in graphs) {
var generatorNum2 = 0
var loadNum2 = 0
var busbarNum2 = 0
var shuntCompensatorNum2 = 0
var seriesCompensatorNum2 = 0
var aclineNum2 = 0
var connlineNum2 = 0
var windingNum2 = 0
var switchNum2 = 0
val cnInGraph = g.vertexSet().filterNot { it.endsWith(suffixOfAddedCn) }
cnInGraph.forEach { obj -> getTerminalsOfCN(getResource(obj)!!).map { getEquipOfTerminal(it) }.forEach {
if (it?.type == "SYNCHRONOUSMACHINE")
generatorNum2++
else if (it?.type == "ENERGYCONSUMER")
loadNum2++
else if (it?.type == "BUSBARSECTION")
busbarNum2++
else if (it?.type == "SHUNTCOMPENSATOR")
shuntCompensatorNum2++
else if (it?.type == "SERIESCOMPENSATOR")
seriesCompensatorNum2++
else if (it?.type == "ACLINESEGMENT")
aclineNum2++
else if (it?.type == "CONNLINE")
connlineNum2++
else if (it?.type == "TRANSFORMERWINDING")
windingNum2++
else if (it != null && isSwitch(it))
switchNum2++
}}
aclineNum2 /= 2
connlineNum2 /= 2
seriesCompensatorNum2 /= 2
switchNum2 /= 2
generatorNum += generatorNum2
loadNum += loadNum2
busbarNum += busbarNum2
shuntCompensatorNum += shuntCompensatorNum2
seriesCompensatorNum += seriesCompensatorNum2
aclineNum += aclineNum2
connlineNum += connlineNum2
windingNum += windingNum2
switchNum += switchNum2
println("====================== " + i++ + " th island information =======================")
println("There are $generatorNum2 generators.")
println("There are $loadNum2 loads.")
println("There are $busbarNum2 bus bar sections.")
println("There are $shuntCompensatorNum2 shunt compensators.")
println("There are $seriesCompensatorNum2 series compensators.")
println("There are $aclineNum2 ac lines.")
println("There are $connlineNum2 conn lines.")
println("There are $windingNum2 transformer winding.")
println("There are $switchNum2 switches.")
}
generators = HashMap<String, MapObject>(generatorNum)
loads = HashMap<String, MapObject>(loadNum)
busbars = HashMap<String, MapObject>(busbarNum)
shuntCompensators = HashMap<String, MapObject>(shuntCompensatorNum)
seriesCompensators = HashMap<String, MapObject>(seriesCompensatorNum)
aclines = HashMap<String, MapObject>(aclineNum)
connlines = HashMap<String, MapObject>(connlineNum)
windings = HashMap<String, MapObject>(windingNum)
transformers = HashMap<String, MapObject>(windingNum / 2)
switches = HashMap<String, MapObject>(switchNum)
for (g in graphs)
g.vertexSet().filterNot { it.endsWith(suffixOfAddedCn) }.forEach { cn -> getTerminalsOfCN(getResource(cn)!!)
.mapNotNull { getEquipOfTerminal(it) }
.forEach {
if (it.type == "SYNCHRONOUSMACHINE")
generators!!.put(it.id, it)
else if (it.type == "ENERGYCONSUMER")
loads!!.put(it.id, it)
else if (it.type == "BUSBARSECTION")
busbars!!.put(it.id, it)
else if (it.type == "SHUNTCOMPENSATOR")
shuntCompensators!!.put(it.id, it)
else if (it.type == "TRANSFORMERWINDING") {
windings!!.put(it.id, it)
val transformer = getTfOfWinding(it)
if (transformer == null) {
System.err.println("Transformer winding does not belong to any transformer, id:" + it.id + " name:" + it.name)
} else if (!transformers!!.containsKey(transformer.id))
transformers!!.put(transformer.id, transformer)
} else if (it.type == "SERIESCOMPENSATOR") {
if (!seriesCompensators!!.containsKey(it.id))
seriesCompensators!!.put(it.id, it)
} else if (it.type == "ACLINESEGMENT") {
if (!aclines!!.containsKey(it.id))
aclines!!.put(it.id, it)
} else if (it.type == "CONNLINE") {
if (!connlines!!.containsKey(it.id))
connlines!!.put(it.id, it)
} else if (isSwitch(it)) {
if (!switches!!.containsKey(it.id))
switches!!.put(it.id, it)
}
}
}
extraFilterDevices(graphs)
println("=========== needed generators num: " + generators!!.size)
println("=========== needed load num: " + loads!!.size)
println("=========== needed bus bar num: " + busbars!!.size)
println("=========== needed shunt compensator num: " + shuntCompensators!!.size)
println("=========== needed series compensator num: " + seriesCompensators!!.size)
println("=========== needed ac line num: " + aclines!!.size)
println("=========== needed conn line num: " + connlines!!.size)
println("=========== needed winding num: " + windings!!.size)
println("=========== needed transformer num: " + transformers!!.size)
println("=========== needed switch num: " + switches!!.size)
println("=========== needed connectivity node num: " + cnNum)
}
open fun extraFilterDevices(graphes : MutableList<Subgraph<String, Edge, *>>) {}
/**
* 分析需要的量测信息
*/
open fun filterMeasure() {
println("Checking measurement start..")
val start = System.currentTimeMillis()
analogs = HashMap(6000)//todo:size is not good
discretes = HashMap(switches!!.size)
equipMeasurements = HashMap()
findAnalogs(generators!!.values)
findAnalogs(loads!!.values)
findAnalogs(busbars!!.values)
findAnalogs(shuntCompensators!!.values)
findAnalogs(seriesCompensators!!.values)
findAnalogs(aclines!!.values)
findAnalogs(connlines!!.values)
findAnalogs(windings!!.values)
findDiscretes(switches!!.values)
println("=========== needed analog measurement num: " + analogs!!.size)
println("=========== needed discrete measurement num: " + discretes!!.size)
println("Checking measurement end, and time used: " + (System.currentTimeMillis() - start) + "ms")
}
//todo:支只处理了开关位置,变压器档位等量测没有处理
private fun findDiscretes(switches: Collection<MapObject>) {
switches.mapNotNull { measureProvider?.getDiscreteOfEquip(it.id, dataSource) }
.mapNotNull { getResource(it.id) }
.forEach { discretes!!.put(it.id, it) }
}
private fun findAnalogs(equips: Collection<MapObject>) {
for (obj in equips) {
val measurements = measureProvider?.getAnalogsOfEquip(obj.id, dataSource) ?: continue
equipMeasurements!!.put(obj.id, measurements)
measurements.mapNotNull { getResource(it.id) }
.forEach { analogs!!.put(it.id, it) }
}
}
// ---------------------------- 拓扑分析开始 -------------------------------
/**
* 根据开关状态分析网络拓扑
*/
fun buildDynamicTopo() : List<Subgraph<TN, Edge, UndirectedGraph<TN, Edge>>> {
var size = 0
activeSubgraphes.forEach { size += it.vertexSet().size }
val cnToTn: MutableMap<String, TN> = HashMap(size)
// 将闭合开关连在一起的CN都合并在一个TN里
getAllSwitch().filter { measureProvider!!.getSwitchStatus(it.id, dataSource) }.forEach {
val terminals = getTerminalsOfEquip(it)
val cn1 = terminals[0].getProperty("CONNECTIVITYNODE")
val cn2 = terminals[1].getProperty("CONNECTIVITYNODE")
@Suppress("LoopToCallChain")
for(g in activeSubgraphes) {
if(g.containsEdge(cn1, cn2)) {
val tn : TN
if(cnToTn.containsKey(cn1)) {
if(cnToTn.containsKey(cn2))
break
tn = cnToTn[cn1]!!
tn.cns.add(cn2)
cnToTn[cn2] = tn
} else if(cnToTn.containsKey(cn2)) {
if (cnToTn.containsKey(cn1))
break
tn = cnToTn[cn2]!!
tn.cns.add(cn1)
cnToTn[cn1] = tn
} else {
tn = TN()
cnToTn[cn1] = tn
cnToTn[cn2] = tn
tn.cns.add(cn1)
tn.cns.add(cn2)
}
break
}
}
}
val tnToGraph = HashMap<TN, UndirectedGraph<TN, Edge>>()
val islands = LinkedList<Subgraph<TN, Edge, UndirectedGraph<TN, Edge>>>()
// 开始构建TN与SimpleGraph之间的关系
for(g in activeSubgraphes) {
val largeG = SimpleGraph<TN, Edge>(Edge::class.java)
g.vertexSet().forEach {
if(!cnToTn.containsKey(it)) {
val tn = TN()
cnToTn[it] = tn
tn.cns.add(it)
largeG.addVertex(tn)
tnToGraph[tn] = largeG
} else {
val tn = cnToTn[it]!!
if(!tnToGraph.containsKey(tn)) {
largeG.addVertex(tn)
tnToGraph[tn] = largeG
}
}
}
g.edgeSet().forEach {
//如果支路是断开的开关则不加入到图
if(it.equips.size == 1 && measureProvider!!.getSwitchStatus(it.equips[0], dataSource))
return@forEach
val cn1 = g.getEdgeSource(it)
val cn2 = g.getEdgeTarget(it)
val tn1 = cnToTn[cn1]
val tn2 = cnToTn[cn2]
if(tn1 != tn2) {
val e = largeG.getEdge(tn1, tn2)
if (e == null) {//如果不存在边
val edge = Edge()
edge.equips.addAll(it.equips)
largeG.addEdge(tn1, tn2, edge)
} else //两条Edge合并
e.equips.addAll(it.equips)
}
}
// 连通性分析
val inspector = ConnectivityInspector(largeG)
val graphs = inspector.connectedSets() //获得连通子图
// 开始建立
graphs.mapTo(islands) { Subgraph<TN, Edge, UndirectedGraph<TN, Edge>>(largeG, it) }
}
return islands
}
inner class CimXmlHandler : DefaultHandler() {
// 使用栈这个数据结构来保存
private val stack = Stack<String>()
private var obj: MapObject? = null
private var obj_constructing = false
private var obj_type: String? = null
private var startTime : Long = 0
@Throws(SAXException::class)
override fun startDocument() {
println("start document -> parse begin")
startTime = System.currentTimeMillis()
}
@Throws(SAXException::class)
override fun endDocument() {
println("end document -> parse finished, time used ${System.currentTimeMillis() - startTime} ms.")
// 文档结束之后建立对象之间的关系
endAddPSR()
}
@Throws(SAXException::class)
override fun startElement(uri: String?, localName: String?, qName: String?,
attributes: Attributes?) {
// 将标签名压入栈
stack.push(qName)
// 处理属性
if (attributes!!.length >= 1) {
if (attributes.getQName(0) == "rdf:ID") {//判断是否遇见带有id的元素，即二级元素
obj = MapObject() //生成一个新的obj空间
obj_constructing = true //构造开始
val index = qName!!.indexOf(":")
//记录当前obj_type，用以确认obj构造结束时刻,去掉前缀
obj_type = qName.substring(index + 1).toUpperCase()
obj!!.id = attributes.getValue(0) //obj初始化
obj!!.type = obj_type
}
if (attributes.getQName(0) == "rdf:resource") {
var tag: String = qName!! // 取出标签名
if (tag.indexOf('.') >= 0) {//tag的简单处理
tag = tag.substring(tag.indexOf('.') + 1, tag.length) //取出原tag中的.后子字符串
}
var value = attributes.getValue(0)
value = value.substring(1, value.length) //去除#后的sub值,end值需要大1
if (value.trim { it <= ' ' } != "") {
obj!!.setProperty(tag.toUpperCase(), value)//存入characters
}
}
}
}
@Throws(SAXException::class)
override fun characters(ch: CharArray?, start: Int, length: Int) {
val value = String(ch!!, start, length)
// 取出标签名
var tag = stack.peek()
//空白值不保存
if ((value.trim { it <= ' ' } != "") and (tag != obj_type)) {
if (obj_constructing) {
if (tag.indexOf('.') >= 0) {
//取出原tag中的.后子字符串，end值需要大1
tag = tag.substring(tag.indexOf('.') + 1, tag.length)
}
obj!!.setProperty(tag.toUpperCase(), value)//存入characters
}
}
}
@Throws(SAXException::class)
override fun endElement(uri: String?, localName: String?, qName: String?) {
//表示该元素解析完毕，需要从栈中弹出标签
stack.pop()
val index = qName!!.indexOf(":")
if (obj_type == qName.substring(index + 1).toUpperCase()) {//判断obj构造是否结束
addPSR(obj!!)
obj_constructing = false//构造结束
}
}
}
}
\ No newline at end of file
availCap/src/main/resources/log4j.properties 0 → 100644
###=====================================================================================
### appenders
###=====================================================================================
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct log messages to daily file ###
log4j.appender.DailyFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DailyFile.File=c:/logs/aems.log
log4j.appender.DailyFile.DatePattern='.'yyyy-MM-dd
log4j.appender.DailyFile.layout=org.apache.log4j.PatternLayout
log4j.appender.DailyFile.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{2} %x %m%n
###=====================================================================================
### log level
###=====================================================================================
### the root
log4j.rootLogger=debug,stdout
#log4j.logger.org.mule=warn,stdout
log4j.logger.com.danga.MemCached.MemCachedClient=warn,stdout
log4j.logger.org.quartz=warn,stdout
#log4j.logger.zju.common.NewtonSolver=debug,stdout
availCap/src/main/resources/log4j2.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %l - %msg%n"/>
<ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
</Console>
<File name="FileAppender" fileName="log/test.log" append="false">
<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %l - %msg%n"/>
</File>
</Appenders>
<Loggers>
<Root level="info">
<AppenderRef ref="Console"/>
<AppenderRef ref="FileAppender"/>
</Root>
</Loggers>
</Configuration>
\ No newline at end of file
build.gradle 0 → 100644
buildscript {
ext.kotlin_version = '1.1.51'
repositories {
mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
allprojects {
apply plugin: 'java'
apply plugin: 'kotlin'
group 'cn.zju'
version '1.0-SNAPSHOT'
sourceCompatibility = 1.8
repositories {
mavenCentral()
maven {
credentials { username 'admin'; password 'admin19881109' }
url "http://dsp.sgool.cn:8887/nexus/content/repositories/releases"
}
}
dependencies {
}
// 编码设置
tasks.withType(Javadoc) { options.encoding = "UTF-8" }
tasks.withType(JavaCompile) { options.encoding = "UTF-8" }
}
\ No newline at end of file
settings.gradle 0 → 100644
include 'availCap'
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论