From d903472d6fd528fcf72bf68e3752cc0978b72e38 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Mon, 26 Nov 2018 14:21:50 +0100 Subject: [PATCH 01/14] Fix compilation issue with LoadFlow interface --- py-powsybl/Demo1.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/py-powsybl/Demo1.py b/py-powsybl/Demo1.py index 21d02f96..61057f73 100644 --- a/py-powsybl/Demo1.py +++ b/py-powsybl/Demo1.py @@ -42,6 +42,8 @@ def dumpLinesFlow(network): computationManager = gateway.jvm.LocalComputationManager() loadflowfactory=defaultConfig.newFactoryImpl(ReflectionUtil.classForName("com.powsybl.loadflow.LoadFlowFactory")) +lf_para = gateway.jvm.com.powsybl.loadflow.LoadFlowParameters.load() + #create a demo network network = gateway.jvm.com.powsybl.iidm.network.test.FictitiousSwitchFactory.create() @@ -52,7 +54,7 @@ def dumpLinesFlow(network): dumpLinesFlow(network) #run a LF on the network and dump its results metrics -loadflowResult = loadFlow.run() +loadflowResult = loadFlow.run(network.getStateManager().getWorkingStateId(), lf_para).get() print("\nLF result: " + str(loadflowResult.isOk()) + "; metrics: " + str(loadflowResult.getMetrics())) #dump network's lines flow @@ -63,7 +65,7 @@ def dumpLinesFlow(network): network.getSwitch("BD").setOpen(True) #re-run a LF on the network and dump its results metrics -loadflowResult = loadFlow.run() +loadflowResult = loadFlow.run(network.getStateManager().getWorkingStateId(), lf_para).get() print("\nLF result: " + str(loadflowResult.isOk()) + "; metrics: " + str(loadflowResult.getMetrics())) #dump network's lines flow From 8cb7dcb05da9484677c6d04bbbeffdc42672fa3d Mon Sep 17 00:00:00 2001 From: yichen88 Date: Tue, 27 Nov 2018 13:31:39 +0100 Subject: [PATCH 02/14] Add wrapper code in pypowsybl module --- py-powsybl/README.md | 22 ++++++++ py-powsybl/pypowsybl/__init__.py | 88 ++++++++++++++++++++++++++++++++ 2 files changed, 110 insertions(+) create mode 100644 py-powsybl/pypowsybl/__init__.py diff --git a/py-powsybl/README.md b/py-powsybl/README.md index f2ba1da9..f8fbc45b 100644 --- a/py-powsybl/README.md +++ b/py-powsybl/README.md @@ -27,6 +27,28 @@ Start the py-powsybl 'server' in a console. Demo1.py demostrates what can be done (it executes a loadflow on a network, opens a switch, exports a network to a file in xiidm format) python Demo1.py + +Another example using pypowsybl module + +``` +from pypowsybl import * + +load("/path/to/case-file/example.xiidm") + +lf = run_load_flow() +print("\nLF result: " + str(lf.isOk()) + "; metrics: " + str(lf.getMetrics())) + +network = get_network() +# modify network + +# re-run load flow +lf = run_load_flow() +print("\nLF result: " + str(lf.isOk()) + "; metrics: " + str(lf.getMetrics())) +save("/path/to/output/example.xiidm") + +# shundown jvm +shundown_pypowsybl() +``` ### Stop py-powsybl To stop the py-powsybl 'server', CTRL+C in the itools console. diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py new file mode 100644 index 00000000..26ccc2c8 --- /dev/null +++ b/py-powsybl/pypowsybl/__init__.py @@ -0,0 +1,88 @@ +# Copyright (c) 2018, RTE (http://www.rte-france.com) +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import sys + +from py4j.java_gateway import JavaGateway, GatewayParameters +from py4j.java_gateway import java_import + +# connect to the JVM (running iPST/PowSyBl) +gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_field=True)) + +# other boilerplate imports +java_import(gateway.jvm, 'java.nio.file.Paths') +java_import(gateway.jvm, 'java.io.*') +java_import(gateway.jvm, 'java.util.Properties') +java_import(gateway.jvm, 'java.lang.String') + +java_import(gateway.jvm, 'com.powsybl.commons.config.ComponentDefaultConfig') +java_import(gateway.jvm, 'com.powsybl.computation.local.LocalComputationManager') +java_import(gateway.jvm, 'com.powsybl.loadflow.LoadFlowFactory') +java_import(gateway.jvm, 'com.powsybl.iidm.import_.Importers') +java_import(gateway.jvm, 'com.powsybl.iidm.export.Exporters') +java_import(gateway.jvm, 'com.powsybl.iidm.network.test.FictitiousSwitchFactory') + +# java_import(gateway.jvm, 'py4j.GatewayServer') +# server = gateway.jvm.py4j.GatewayServer() + +string_class = gateway.jvm.java.lang.String + +default_exporter_properties = gateway.jvm.java.util.Properties() + +# needed below to resolve some class-factories, by name +ReflectionUtil = gateway.jvm.py4j.reflection.ReflectionUtil + +# load platform config +defaultConfig = gateway.jvm.ComponentDefaultConfig.load() + +# instantiate a computation manager and a LF factory +computation_manager = gateway.jvm.LocalComputationManager() +lf_factory = defaultConfig.newFactoryImpl(ReflectionUtil.classForName("com.powsybl.loadflow.LoadFlowFactory")) + +lf_para = gateway.jvm.com.powsybl.loadflow.LoadFlowParameters.load() +importer = gateway.jvm.com.powsybl.iidm.import_.Importers +exporter = gateway.jvm.com.powsybl.iidm.export.Exporters +network = None + + +def load(path): + global network + network = importer.loadNetwork(path) + + +def run_load_flow(): + if network is None: + sys.exit('network is null!') + + # instantiate a LF + load_flow = lf_factory.create(network, computation_manager, 0) + lf_result = load_flow.run(network.getStateManager().getWorkingStateId(), lf_para).join() + return lf_result + + +def get_network(): + return network + + +def save(str_path): + # convert string path to jvm string array + split = str_path.split("/") + length = len(split) + str_array = gateway.new_array(string_class, length) + for i in range(length): + str_array[i] = split[i] + + # find format + foo = str_array[length-1].split(".") + ext = foo[len(foo)-1] + export_format = ext.upper() + + dest_path = gateway.jvm.java.nio.file.Paths.get("/", str_array) + + exporter.export(export_format, network, default_exporter_properties, dest_path) + + +def shundown_pypowsybl(): + gateway.shutdown() From 729614e55c686557bd77ddb23b1316fdf5b35fd2 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Thu, 29 Nov 2018 12:28:01 +0100 Subject: [PATCH 03/14] Configurable py-powsybl server's port --- .../main/java/com/powsybl/powsybl/PyPowsybl.java | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/py-powsybl/src/main/java/com/powsybl/powsybl/PyPowsybl.java b/py-powsybl/src/main/java/com/powsybl/powsybl/PyPowsybl.java index 6e8ecd3c..5befa33c 100644 --- a/py-powsybl/src/main/java/com/powsybl/powsybl/PyPowsybl.java +++ b/py-powsybl/src/main/java/com/powsybl/powsybl/PyPowsybl.java @@ -11,6 +11,7 @@ import com.powsybl.tools.Tool; import com.powsybl.tools.ToolRunningContext; import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.Option; import org.apache.commons.cli.Options; import py4j.GatewayServer; @@ -20,6 +21,8 @@ @AutoService(Tool.class) public class PyPowsybl implements Tool { + private static final String PORT = "port"; + @Override public Command getCommand() { return new Command() { @@ -42,6 +45,11 @@ public String getDescription() { @Override public Options getOptions() { Options options = new Options(); + options.addOption(Option.builder().longOpt(PORT) + .desc("port for python to connect") + .hasArg() + .argName("PORT") + .build()); return options; } @@ -55,8 +63,9 @@ public String getUsageFooter() { @Override public void run(CommandLine line, ToolRunningContext context) throws Exception { + int port = Integer.parseInt(line.getOptionValue(PORT, "25333")); - GatewayServer server = new GatewayServer(); + GatewayServer server = new GatewayServer("entry_point", port); Runtime.getRuntime().addShutdownHook(new Thread() { public void run() { @@ -67,9 +76,10 @@ public void run() { }); // execute the py4j Gateway service - //TODO customize service parameters: address, port, ..... + //TODO customize service parameters: address, ..... server.start(); - System.out.println("py-powsybl server started; CTRL+C to stop it"); + System.out.println("py-powsybl server started at " + server.getAddress() + ":" + port); + System.out.println("CTRL+C to stop it"); } } From d86f4db5e07a4004f5ac63931c2daa67008b62a3 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Thu, 29 Nov 2018 12:35:25 +0100 Subject: [PATCH 04/14] Use python class wrap java's instance --- py-powsybl/README.md | 35 +++-- py-powsybl/pypowsybl/__init__.py | 227 +++++++++++++++++++++++-------- 2 files changed, 196 insertions(+), 66 deletions(-) diff --git a/py-powsybl/README.md b/py-powsybl/README.md index f8fbc45b..4d398d6d 100644 --- a/py-powsybl/README.md +++ b/py-powsybl/README.md @@ -33,21 +33,34 @@ Another example using pypowsybl module ``` from pypowsybl import * -load("/path/to/case-file/example.xiidm") +# simple dump network flows function +def dump_lines_flow(network): + print(len(network.get_lines())) + for l in network.get_lines(): + print(l.get_id() + ";" + str(l.get_terminal_1().get_i()) + ";" + str(l.get_terminal_2().get_i())) -lf = run_load_flow() -print("\nLF result: " + str(lf.isOk()) + "; metrics: " + str(lf.getMetrics())) -network = get_network() -# modify network +if __name__ == '__main__': + if connect(3338): + n1 = load("/path/to/case-file/example.xiidm") + dump_lines_flow(n1) -# re-run load flow -lf = run_load_flow() -print("\nLF result: " + str(lf.isOk()) + "; metrics: " + str(lf.getMetrics())) -save("/path/to/output/example.xiidm") + lf = run_load_flow(n1) + print("\nLF result: " + str(lf.is_ok()) + "; metrics: " + str(lf.get_metrics())) + dump_lines_flow(n1) + + # re-run load flow alternatively + lf = n1.run_load_flow() + print("\nLF result: " + str(lf.is_ok()) + "; metrics: " + str(lf.get_metrics())) + + n1.save("/path/to/output/example.xiidm") + # or save(n1, "/path/to/output/example.xiidm") + + # shundown jvm + # shundown_pypowsybl() + else: + print("can not connect to jvm") -# shundown jvm -shundown_pypowsybl() ``` ### Stop py-powsybl diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 26ccc2c8..10ab3f51 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -3,70 +3,82 @@ # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. -import sys - from py4j.java_gateway import JavaGateway, GatewayParameters from py4j.java_gateway import java_import - -# connect to the JVM (running iPST/PowSyBl) -gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_field=True)) - -# other boilerplate imports -java_import(gateway.jvm, 'java.nio.file.Paths') -java_import(gateway.jvm, 'java.io.*') -java_import(gateway.jvm, 'java.util.Properties') -java_import(gateway.jvm, 'java.lang.String') - -java_import(gateway.jvm, 'com.powsybl.commons.config.ComponentDefaultConfig') -java_import(gateway.jvm, 'com.powsybl.computation.local.LocalComputationManager') -java_import(gateway.jvm, 'com.powsybl.loadflow.LoadFlowFactory') -java_import(gateway.jvm, 'com.powsybl.iidm.import_.Importers') -java_import(gateway.jvm, 'com.powsybl.iidm.export.Exporters') -java_import(gateway.jvm, 'com.powsybl.iidm.network.test.FictitiousSwitchFactory') - -# java_import(gateway.jvm, 'py4j.GatewayServer') -# server = gateway.jvm.py4j.GatewayServer() - -string_class = gateway.jvm.java.lang.String - -default_exporter_properties = gateway.jvm.java.util.Properties() - -# needed below to resolve some class-factories, by name -ReflectionUtil = gateway.jvm.py4j.reflection.ReflectionUtil - -# load platform config -defaultConfig = gateway.jvm.ComponentDefaultConfig.load() - -# instantiate a computation manager and a LF factory -computation_manager = gateway.jvm.LocalComputationManager() -lf_factory = defaultConfig.newFactoryImpl(ReflectionUtil.classForName("com.powsybl.loadflow.LoadFlowFactory")) - -lf_para = gateway.jvm.com.powsybl.loadflow.LoadFlowParameters.load() -importer = gateway.jvm.com.powsybl.iidm.import_.Importers -exporter = gateway.jvm.com.powsybl.iidm.export.Exporters -network = None +from py4j.protocol import Py4JError + +gateway = None +string_class = None + +importer = None +exporter = None + +lf_para = None +defaultConfig = None +default_exporter_properties = None + + +def connect(nb_port): + # connect to the JVM (running iPST/PowSyBl) + global gateway + try: + gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_field=True,port=nb_port)) + + # other boilerplate imports + java_import(gateway.jvm, 'java.nio.file.Paths') + java_import(gateway.jvm, 'java.io.*') + java_import(gateway.jvm, 'java.util.Properties') + java_import(gateway.jvm, 'java.lang.String') + + java_import(gateway.jvm, 'com.powsybl.commons.config.ComponentDefaultConfig') + java_import(gateway.jvm, 'com.powsybl.computation.local.LocalComputationManager') + java_import(gateway.jvm, 'com.powsybl.loadflow.LoadFlowFactory') + java_import(gateway.jvm, 'com.powsybl.iidm.import_.Importers') + java_import(gateway.jvm, 'com.powsybl.iidm.export.Exporters') + java_import(gateway.jvm, 'com.powsybl.iidm.network.test.FictitiousSwitchFactory') + + global string_class + string_class = gateway.jvm.java.lang.String + + global default_exporter_properties + default_exporter_properties = gateway.jvm.java.util.Properties() + + # needed below to resolve some class-factories, by name + ReflectionUtil = gateway.jvm.py4j.reflection.ReflectionUtil + + # load platform config + global defaultConfig + defaultConfig = gateway.jvm.ComponentDefaultConfig.load() + + # instantiate a computation manager and a LF factory + global computation_manager + computation_manager = gateway.jvm.LocalComputationManager() + global lf_factory + lf_factory = defaultConfig.newFactoryImpl(ReflectionUtil.classForName("com.powsybl.loadflow.LoadFlowFactory")) + global lf_para + lf_para = gateway.jvm.com.powsybl.loadflow.LoadFlowParameters.load() + global importer + importer = gateway.jvm.com.powsybl.iidm.import_.Importers + global exporter + exporter = gateway.jvm.com.powsybl.iidm.export.Exporters + return True + except Py4JError: + return False def load(path): - global network - network = importer.loadNetwork(path) - + return Network(importer.loadNetwork(path)) -def run_load_flow(): - if network is None: - sys.exit('network is null!') +def run_load_flow(network): # instantiate a LF - load_flow = lf_factory.create(network, computation_manager, 0) - lf_result = load_flow.run(network.getStateManager().getWorkingStateId(), lf_para).join() - return lf_result - + jnetwork = network.get_java_network() + load_flow = lf_factory.create(jnetwork, computation_manager, 0) + lf_result = load_flow.run(jnetwork.getStateManager().getWorkingStateId(), lf_para).join() + return LoadFlowResult(lf_result) -def get_network(): - return network - -def save(str_path): +def save(network, str_path): # convert string path to jvm string array split = str_path.split("/") length = len(split) @@ -81,8 +93,113 @@ def save(str_path): dest_path = gateway.jvm.java.nio.file.Paths.get("/", str_array) - exporter.export(export_format, network, default_exporter_properties, dest_path) + exporter.export(export_format, network.get_java_network(), default_exporter_properties, dest_path) def shundown_pypowsybl(): gateway.shutdown() + + +class Network: + + def __init__(self, java_network): + self.j_instance = java_network + + def get_java_network(self): + return self.j_instance + + def run_load_flow(self): + return run_load_flow(self) + + def save(self, path): + save(self, path) + + def get_line(self, id): + return self.j_instance.getLine(id) + + def get_lines(self): + j_lines = self.j_instance.getLines().toList() + lines = [] + for l in j_lines: + ll = Line(l) + lines.append(ll) + return lines + + +class LoadFlowResult: + + def __init__(self, j_lf_res): + self.j_instance = j_lf_res + + def is_ok(self): + return self.j_instance.isOk() + + def get_metrics(self): + return self.j_instance.getMetrics() + + def get_logs(self): + return self.j_instance.getLogs() + + +class Identifiable: + + def __init__(self, j_identifiable): + self.j_instance = j_identifiable + + def get_id(self): + return self.j_instance.getId() + + +class Branch(Identifiable): + + def __init__(self, j_branch): + Identifiable.__init__(self, j_branch) + self.j_instance = j_branch + + def is_overloaded(self): + return self.j_instance.isOverloaded() + + def get_terminal_1(self): + return Terminal(self.j_instance.getTerminal1()) + + def get_terminal_2(self): + return Terminal(self.j_instance.getTerminal2()) + + +class Line(Branch): + + def __init__(self, j_line): + Branch.__init__(self, j_line) + self.j_instance = j_line + + +class Terminal: + + def __init__(self, j_terminal): + self.j_instance = j_terminal + + def set_p(self, p): + self.j_instance.setP(p) + return self + + def set_q(self, q): + self.j_instance.setQ(q) + return self + + def get_p(self): + return self.j_instance.getP() + + def get_q(self): + return self.j_instance.getQ() + + def get_i(self): + return self.j_instance.getI() + + def connect(self): + return self.j_instance.connect() + + def disconnect(self): + return self.j_instance.disconnect() + + def is_connected(self): + return self.j_instance.isConnected() From 7774aabbdd05ed19f5422871b982ff07e7e342a8 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Fri, 30 Nov 2018 12:11:01 +0100 Subject: [PATCH 05/14] Launch java server by python with config-name --- py-powsybl/README.md | 8 +++++--- py-powsybl/pypowsybl/__init__.py | 27 +++++++++++++++++++++++++++ 2 files changed, 32 insertions(+), 3 deletions(-) diff --git a/py-powsybl/README.md b/py-powsybl/README.md index 4d398d6d..6c6283c2 100644 --- a/py-powsybl/README.md +++ b/py-powsybl/README.md @@ -41,7 +41,9 @@ def dump_lines_flow(network): if __name__ == '__main__': - if connect(3338): + port = 3338 + launch("config2", port) + if connect(port): n1 = load("/path/to/case-file/example.xiidm") dump_lines_flow(n1) @@ -56,8 +58,8 @@ if __name__ == '__main__': n1.save("/path/to/output/example.xiidm") # or save(n1, "/path/to/output/example.xiidm") - # shundown jvm - # shundown_pypowsybl() + # don't forget to shundown jvm + shundown_pypowsybl() else: print("can not connect to jvm") diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 10ab3f51..44565a26 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -2,6 +2,9 @@ # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. +import subprocess +import time +from threading import Thread from py4j.java_gateway import JavaGateway, GatewayParameters from py4j.java_gateway import java_import @@ -17,11 +20,30 @@ defaultConfig = None default_exporter_properties = None +retried = 0 + +def launch_task(config_name, nb_port): + if config_name is None: + cmd = 'itools py-powsybl -port=' + str(nb_port) + else: + cmd = 'itools --config-name ' + config_name + ' py-powsybl -port=' + str(nb_port) + subprocess.call([cmd], shell=True) + + +def launch(nb_port): + launch(None, nb_port) + + +def launch(config_name, nb_port): + t = Thread(target=launch_task, args=(config_name, nb_port)) + t.start() + def connect(nb_port): # connect to the JVM (running iPST/PowSyBl) global gateway try: + time.sleep(1) gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_field=True,port=nb_port)) # other boilerplate imports @@ -63,6 +85,11 @@ def connect(nb_port): exporter = gateway.jvm.com.powsybl.iidm.export.Exporters return True except Py4JError: + global retried + while retried < 5: + retried = retried + 1 + print("retring..." + retried) + connect(nb_port) return False From 14d2aaf8cbc30432d34f0cb953493386bd7d0521 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Fri, 30 Nov 2018 16:01:30 +0100 Subject: [PATCH 06/14] Generate python wrapper --- py-powsybl/pypowsybl/__init__.py | 887 +++++++++++++++++- .../powsybl/powsybl/PythonCodeGenerator.java | 265 ++++++ 2 files changed, 1116 insertions(+), 36 deletions(-) create mode 100644 py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 44565a26..767e2a24 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -4,6 +4,7 @@ # file, You can obtain one at http://mozilla.org/MPL/2.0/. import subprocess import time +from enum import Enum from threading import Thread from py4j.java_gateway import JavaGateway, GatewayParameters @@ -88,7 +89,7 @@ def connect(nb_port): global retried while retried < 5: retried = retried + 1 - print("retring..." + retried) + print("retring..." + str(retried)) connect(nb_port) return False @@ -127,10 +128,240 @@ def shundown_pypowsybl(): gateway.shutdown() -class Network: +class Identifiable: + + def __init__(self, j_identifiable): + self.j_instance = j_identifiable + + def get_id(self): + return self.j_instance.getId() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Network +class Network(Identifiable): + + def __init__(self, j_network): + Identifiable.__init__(self, j_network) + self.j_instance = j_network + + def add_listener(self, var0): + self.j_instance.addListener(var0) + + def get_branch(self, var0): + return Branch(self.j_instance.getBranch(var0)) + + def get_branch_count(self): + return self.j_instance.getBranchCount() + + def get_branches(self): + l_branch = [] + for j_e in self.j_instance.getBranches().toList(): + l_branch.append(Branch(j_e)) + return l_branch + + def get_busbar_section(self, var0): + return BusbarSection(self.j_instance.getBusbarSection(var0)) + + def get_busbar_section_count(self): + return self.j_instance.getBusbarSectionCount() + + def get_busbar_sections(self): + l_busbarsection = [] + for j_e in self.j_instance.getBusbarSections().toList(): + l_busbarsection.append(BusbarSection(j_e)) + return l_busbarsection + + def get_country_count(self): + return self.j_instance.getCountryCount() + + def get_dangling_line(self, var0): + return DanglingLine(self.j_instance.getDanglingLine(var0)) + + def get_dangling_line_count(self): + return self.j_instance.getDanglingLineCount() + + def get_dangling_lines(self): + l_danglingline = [] + for j_e in self.j_instance.getDanglingLines().toList(): + l_danglingline.append(DanglingLine(j_e)) + return l_danglingline + + def get_forecast_distance(self): + return self.j_instance.getForecastDistance() + + def get_generator(self, var0): + return Generator(self.j_instance.getGenerator(var0)) + + def get_generator_count(self): + return self.j_instance.getGeneratorCount() + + def get_generators(self): + l_generator = [] + for j_e in self.j_instance.getGenerators().toList(): + l_generator.append(Generator(j_e)) + return l_generator + + def get_hvdc_converter_station(self, var0): + return HvdcConverterStation(self.j_instance.getHvdcConverterStation(var0)) + + def get_hvdc_converter_station_count(self): + return self.j_instance.getHvdcConverterStationCount() + + def get_hvdc_converter_stations(self): + l_hvdcconverterstation = [] + for j_e in self.j_instance.getHvdcConverterStations().toList(): + l_hvdcconverterstation.append(HvdcConverterStation(j_e)) + return l_hvdcconverterstation + + def get_hvdc_line(self, var0): + return HvdcLine(self.j_instance.getHvdcLine(var0)) + + def get_hvdc_line_count(self): + return self.j_instance.getHvdcLineCount() + + def get_hvdc_lines(self): + l_hvdcline = [] + for j_e in self.j_instance.getHvdcLines().toList(): + l_hvdcline.append(HvdcLine(j_e)) + return l_hvdcline + + def get_identifiable(self, var0): + return Identifiable(self.j_instance.getIdentifiable(var0)) + + def get_lcc_converter_station(self, var0): + return LccConverterStation(self.j_instance.getLccConverterStation(var0)) + + def get_lcc_converter_station_count(self): + return self.j_instance.getLccConverterStationCount() + + def get_lcc_converter_stations(self): + l_lccconverterstation = [] + for j_e in self.j_instance.getLccConverterStations().toList(): + l_lccconverterstation.append(LccConverterStation(j_e)) + return l_lccconverterstation - def __init__(self, java_network): - self.j_instance = java_network + def get_line(self, var0): + return Line(self.j_instance.getLine(var0)) + + def get_line_count(self): + return self.j_instance.getLineCount() + + def get_lines(self): + l_line = [] + for j_e in self.j_instance.getLines().toList(): + l_line.append(Line(j_e)) + return l_line + + def get_load(self, var0): + return Load(self.j_instance.getLoad(var0)) + + def get_load_count(self): + return self.j_instance.getLoadCount() + + def get_loads(self): + l_load = [] + for j_e in self.j_instance.getLoads().toList(): + l_load.append(Load(j_e)) + return l_load + + def get_shunt(self, var0): + return ShuntCompensator(self.j_instance.getShunt(var0)) + + def get_shunt_count(self): + return self.j_instance.getShuntCount() + + def get_shunts(self): + l_shuntcompensator = [] + for j_e in self.j_instance.getShunts().toList(): + l_shuntcompensator.append(ShuntCompensator(j_e)) + return l_shuntcompensator + + def get_source_format(self): + return self.j_instance.getSourceFormat() + + def get_static_var_compensator(self, var0): + return StaticVarCompensator(self.j_instance.getStaticVarCompensator(var0)) + + def get_static_var_compensator_count(self): + return self.j_instance.getStaticVarCompensatorCount() + + def get_static_var_compensators(self): + l_staticvarcompensator = [] + for j_e in self.j_instance.getStaticVarCompensators().toList(): + l_staticvarcompensator.append(StaticVarCompensator(j_e)) + return l_staticvarcompensator + + def get_substation(self, var0): + return Substation(self.j_instance.getSubstation(var0)) + + def get_substation_count(self): + return self.j_instance.getSubstationCount() + + def get_substations(self): + l_substation = [] + for j_e in self.j_instance.getSubstations().toList(): + l_substation.append(Substation(j_e)) + return l_substation + + def get_switch(self, var0): + return Switch(self.j_instance.getSwitch(var0)) + + def get_switch_count(self): + return self.j_instance.getSwitchCount() + + def get_switches(self): + l_switch = [] + for j_e in self.j_instance.getSwitches().toList(): + l_switch.append(Switch(j_e)) + return l_switch + + def get_three_windings_transformer(self, var0): + return ThreeWindingsTransformer(self.j_instance.getThreeWindingsTransformer(var0)) + + def get_three_windings_transformer_count(self): + return self.j_instance.getThreeWindingsTransformerCount() + + def get_three_windings_transformers(self): + l_threewindingstransformer = [] + for j_e in self.j_instance.getThreeWindingsTransformers().toList(): + l_threewindingstransformer.append(ThreeWindingsTransformer(j_e)) + return l_threewindingstransformer + + def get_two_windings_transformer(self, var0): + return TwoWindingsTransformer(self.j_instance.getTwoWindingsTransformer(var0)) + + def get_two_windings_transformer_count(self): + return self.j_instance.getTwoWindingsTransformerCount() + + def get_two_windings_transformers(self): + l_twowindingstransformer = [] + for j_e in self.j_instance.getTwoWindingsTransformers().toList(): + l_twowindingstransformer.append(TwoWindingsTransformer(j_e)) + return l_twowindingstransformer + + def get_voltage_level(self, var0): + return VoltageLevel(self.j_instance.getVoltageLevel(var0)) + + def get_voltage_level_count(self): + return self.j_instance.getVoltageLevelCount() + + def get_voltage_levels(self): + l_voltagelevel = [] + for j_e in self.j_instance.getVoltageLevels().toList(): + l_voltagelevel.append(VoltageLevel(j_e)) + return l_voltagelevel + + def get_vsc_converter_station(self, var0): + return VscConverterStation(self.j_instance.getVscConverterStation(var0)) + + def get_vsc_converter_station_count(self): + return self.j_instance.getVscConverterStationCount() + + def get_vsc_converter_stations(self): + l_vscconverterstation = [] + for j_e in self.j_instance.getVscConverterStations().toList(): + l_vscconverterstation.append(VscConverterStation(j_e)) + return l_vscconverterstation def get_java_network(self): return self.j_instance @@ -141,17 +372,6 @@ def run_load_flow(self): def save(self, path): save(self, path) - def get_line(self, id): - return self.j_instance.getLine(id) - - def get_lines(self): - j_lines = self.j_instance.getLines().toList() - lines = [] - for l in j_lines: - ll = Line(l) - lines.append(ll) - return lines - class LoadFlowResult: @@ -168,19 +388,47 @@ def get_logs(self): return self.j_instance.getLogs() -class Identifiable: +# TODO container +class Substation(Identifiable): - def __init__(self, j_identifiable): - self.j_instance = j_identifiable + def __init__(self, j_substation): + Identifiable.__init__(self, j_substation) - def get_id(self): - return self.j_instance.getId() + def get_tso(self): + return self.j_instance.getTso() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Connectable +class Connectable(Identifiable): + + def __init__(self, j_connectable): + Identifiable.__init__(self, j_connectable) + self.j_instance = j_connectable + + def get_terminals(self): + l_terminal = [] + for j_e in self.j_instance.getTerminals(): + l_terminal.append(Terminal(j_e)) + return l_terminal + + def get_type(self): + return ConnectableType(str(self.j_instance.getType())) -class Branch(Identifiable): +class Injection(Connectable): + + def __init__(self, j_injection): + Connectable.__init__(self, j_injection) + self.j_instance = j_injection + + def get_terminal(self): + return Terminal(self.j_instance.getTerminal()) + + +class Branch(Connectable): def __init__(self, j_branch): - Identifiable.__init__(self, j_branch) + Connectable.__init__(self, j_branch) self.j_instance = j_branch def is_overloaded(self): @@ -193,25 +441,334 @@ def get_terminal_2(self): return Terminal(self.j_instance.getTerminal2()) +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Bus +class Bus(Identifiable): + + def __init__(self, j_bus): + Identifiable.__init__(self, j_bus) + self.j_instance = j_bus + + def get_angle(self): + return self.j_instance.getAngle() + + def get_connected_component(self): + return Component(self.j_instance.getConnectedComponent()) + + def get_connected_terminal_count(self): + return self.j_instance.getConnectedTerminalCount() + + def get_dangling_lines(self): + l_danglingline = [] + for j_e in self.j_instance.getDanglingLines().toList(): + l_danglingline.append(DanglingLine(j_e)) + return l_danglingline + + def get_generators(self): + l_generator = [] + for j_e in self.j_instance.getGenerators().toList(): + l_generator.append(Generator(j_e)) + return l_generator + + def get_lcc_converter_stations(self): + l_lccconverterstation = [] + for j_e in self.j_instance.getLccConverterStations().toList(): + l_lccconverterstation.append(LccConverterStation(j_e)) + return l_lccconverterstation + + def get_lines(self): + l_line = [] + for j_e in self.j_instance.getLines().toList(): + l_line.append(Line(j_e)) + return l_line + + def get_loads(self): + l_load = [] + for j_e in self.j_instance.getLoads().toList(): + l_load.append(Load(j_e)) + return l_load + + def get_p(self): + return self.j_instance.getP() + + def get_q(self): + return self.j_instance.getQ() + + def get_shunt_compensators(self): + l_shuntcompensator = [] + for j_e in self.j_instance.getShuntCompensators().toList(): + l_shuntcompensator.append(ShuntCompensator(j_e)) + return l_shuntcompensator + + def get_static_var_compensators(self): + l_staticvarcompensator = [] + for j_e in self.j_instance.getStaticVarCompensators().toList(): + l_staticvarcompensator.append(StaticVarCompensator(j_e)) + return l_staticvarcompensator + + def get_synchronous_component(self): + return Component(self.j_instance.getSynchronousComponent()) + + def get_three_windings_transformers(self): + l_threewindingtransformer = [] + for j_e in self.j_instance.getThreeWindingsTransformers().toList(): + l_threewindingtransformer.append(ThreeWindingsTransformer(j_e)) + return l_threewindingtransformer + + def get_two_windings_transformers(self): + l_twowindingtransformer = [] + for j_e in self.j_instance.getTwoWindingsTransformers().toList(): + l_twowindingtransformer.append(TwoWindingsTransformer(j_e)) + return l_twowindingtransformer + + def get_v(self): + return self.j_instance.getV() + + def get_voltage_level(self): + return VoltageLevel(self.j_instance.getVoltageLevel()) + + def get_vsc_converter_stations(self): + l_vscconverterstation = [] + for j_e in self.j_instance.getVscConverterStations().toList(): + l_vscconverterstation.append(VscConverterStation(j_e)) + return l_vscconverterstation + + def is_in_main_connected_component(self): + return self.j_instance.isInMainConnectedComponent() + + def is_in_main_synchronous_component(self): + return self.j_instance.isInMainSynchronousComponent() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Component +class Component: + + def __init__(self, j_component): + self.j_instance = j_component + + def get_num(self): + return self.j_instance.getNum() + + def get_buses(self): + l_bus = [] + for j_e in self.j_instance.getBuses().toList(): + l_bus.append(Bus(j_e)) + return l_bus + + def get_size(self): + return self.j_instance.getSize() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.CurrentLimits +class CurrentLimits: + + def __init__(self, j_currentlimits): + self.j_instance = j_currentlimits + + def get_permanent_limit(self): + return self.j_instance.getPermanentLimit() + + def get_temporary_limit_value(self, var0): + return self.j_instance.getTemporaryLimitValue(var0) + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.DanglingLine +class DanglingLine(Injection): + + def __init__(self, j_danglingline): + Injection.__init__(self, j_danglingline) + self.j_instance = j_danglingline + + def get_b(self): + return self.j_instance.getB() + + def get_current_limits(self): + return CurrentLimits(self.j_instance.getCurrentLimits()) + + def get_g(self): + return self.j_instance.getG() + + def get_p0(self): + return self.j_instance.getP0() + + def get_q0(self): + return self.j_instance.getQ0() + + def get_r(self): + return self.j_instance.getR() + + def get_ucte_xnode_code(self): + return self.j_instance.getUcteXnodeCode() + + def get_x(self): + return self.j_instance.getX() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.HvdcConverterStation +class HvdcConverterStation(Injection): + + def __init__(self, j_hvdcconverterstation): + Injection.__init__(self, j_hvdcconverterstation) + self.j_instance = j_hvdcconverterstation + + def get_loss_factor(self): + return self.j_instance.getLossFactor() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.HvdcLine +class HvdcLine(Identifiable): + + def __init__(self, j_hvdcline): + Identifiable.__init__(self, j_hvdcline) + self.j_instance = j_hvdcline + + def get_active_power_setpoint(self): + return self.j_instance.getActivePowerSetpoint() + + def get_converter_station1(self): + return HvdcConverterStation(self.j_instance.getConverterStation1()) + + def get_converter_station2(self): + return HvdcConverterStation(self.j_instance.getConverterStation2()) + + def get_max_p(self): + return self.j_instance.getMaxP() + + def get_network(self): + return Network(self.j_instance.getNetwork()) + + def get_nominal_v(self): + return self.j_instance.getNominalV() + + def get_r(self): + return self.j_instance.getR() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.LccConverterStation +class LccConverterStation(HvdcConverterStation): + + def __init__(self, j_lccconverterstation): + HvdcConverterStation.__init__(self, j_lccconverterstation) + self.j_instance = j_lccconverterstation + + def get_power_factor(self): + return self.j_instance.getPowerFactor() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.VscConverterStation +class VscConverterStation(HvdcConverterStation): + + def __init__(self, j_vscconverterstation): + HvdcConverterStation.__init__(self, j_vscconverterstation) + self.j_instance = j_vscconverterstation + + def get_reactive_limits(self): + return ReactiveLimits(self.j_instance.getReactiveLimits()) + + def get_reactive_power_setpoint(self): + return self.j_instance.getReactivePowerSetpoint() + + def get_voltage_setpoint(self): + return self.j_instance.getVoltageSetpoint() + + def is_voltage_regulator_on(self): + return self.j_instance.isVoltageRegulatorOn() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Line class Line(Branch): def __init__(self, j_line): Branch.__init__(self, j_line) self.j_instance = j_line + def get_b1(self): + return self.j_instance.getB1() + + def get_b2(self): + return self.j_instance.getB2() + + def get_g1(self): + return self.j_instance.getG1() + + def get_g2(self): + return self.j_instance.getG2() + + def get_r(self): + return self.j_instance.getR() + + def get_x(self): + return self.j_instance.getX() + + def is_tie_line(self): + return self.j_instance.isTieLine() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Load +class Load(Injection): + + def __init__(self, j_load): + Injection.__init__(self, j_load) + self.j_instance = j_load + + def get_p0(self): + return self.j_instance.getP0() + + def get_q0(self): + return self.j_instance.getQ0() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Generator +class Generator(Injection): + + def __init__(self, j_generator): + Injection.__init__(self, j_generator) + self.j_instance = j_generator + + def get_target_v(self): + return self.j_instance.getTargetV() + + def get_target_p(self): + return self.j_instance.getTargetP() + def get_target_q(self): + return self.j_instance.getTargetQ() + + def get_rated_s(self): + return self.j_instance.getRatedS() + + def get_regulating_terminal(self): + return Terminal(self.j_instance.getRegulatingTerminal()) + + def is_voltage_regulator_on(self): + return self.j_instance.isVoltageRegulatorOn() + + def get_max_p(self): + return self.j_instance.getMaxP() + + def get_min_p(self): + return self.j_instance.getMinP() + + def get_reactive_limits(self): + return ReactiveLimits(self.j_instance.getReactiveLimits()) + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Terminal class Terminal: def __init__(self, j_terminal): self.j_instance = j_terminal - def set_p(self, p): - self.j_instance.setP(p) - return self + def connect(self): + return self.j_instance.connect() + + def disconnect(self): + return self.j_instance.disconnect() - def set_q(self, q): - self.j_instance.setQ(q) - return self + def get_connectable(self): + return Connectable(self.j_instance.getConnectable()) + + def get_i(self): + return self.j_instance.getI() def get_p(self): return self.j_instance.getP() @@ -219,14 +776,272 @@ def get_p(self): def get_q(self): return self.j_instance.getQ() - def get_i(self): - return self.j_instance.getI() - - def connect(self): - return self.j_instance.connect() - - def disconnect(self): - return self.j_instance.disconnect() + def get_voltage_level(self): + return VoltageLevel(self.j_instance.getVoltageLevel()) def is_connected(self): return self.j_instance.isConnected() + + def traverse(self, var0): + self.j_instance.traverse(var0) + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.ReactiveLimits +class ReactiveLimits: + + def __init__(self, j_reactivelimits): + self.j_instance = j_reactivelimits + + def get_min_q(self): + return self.j_instance.getMinQ() + + def get_max_q(self): + return self.j_instance.getMaxQ() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.ThreeWindingsTransformer +class ThreeWindingsTransformer(Connectable): + + def __init__(self, j_threewindingstransformer): + Connectable.__init__(self, j_threewindingstransformer) + self.j_instance = j_threewindingstransformer + + def get_terminal(self): + return Terminal(self.j_instance.getTerminal()) + + def get_substation(self): + return Substation(self.j_instance.getSubstation()) + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.TwoWindingsTransformer +class TwoWindingsTransformer(Branch): + + def __init__(self, j_twowindingstransformer): + Branch.__init__(self, j_twowindingstransformer) + self.j_instance = j_twowindingstransformer + + def get_r(self): + return self.j_instance.getR() + + def get_x(self): + return self.j_instance.getX() + + def get_g(self): + return self.j_instance.getG() + + def get_b(self): + return self.j_instance.getB() + + def get_rated_u1(self): + return self.j_instance.getRatedU1() + + def get_rated_u2(self): + return self.j_instance.getRatedU2() + + def get_substation(self): + return Substation(self.j_instance.getSubstation()) + + +class BusbarSection(Injection): + + def __init__(self, j_busbar_section): + Injection.__init__(self, j_busbar_section) + self.j_instance = j_busbar_section + + def get_v(self): + return self.j_instance.getV() + + def get_angle(self): + return self.j_instance.getAngle() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.VoltageLevel +# TODO container +class VoltageLevel(Identifiable): + + def __init__(self, j_voltagelevel): + Identifiable.__init__(self, j_voltagelevel) + self.j_instance = j_voltagelevel + + def get_high_voltage_limit(self): + return self.j_instance.getHighVoltageLimit() + + def get_connectables(self): + l_connectable = [] + for j_e in self.j_instance.getConnectables().toList(): + l_connectable.append(Connectable(j_e)) + return l_connectable + + def get_lcc_converter_station_count(self): + return self.j_instance.getLccConverterStationCount() + + def get_connectable_count(self): + return self.j_instance.getConnectableCount() + + def get_generators(self): + l_generator = [] + for j_e in self.j_instance.getGenerators().toList(): + l_generator.append(Generator(j_e)) + return l_generator + + def get_generator_count(self): + return self.j_instance.getGeneratorCount() + + def get_loads(self): + l_load = [] + for j_e in self.j_instance.getLoads().toList(): + l_load.append(Load(j_e)) + return l_load + + def get_switches(self): + l_switch = [] + for j_e in self.j_instance.getSwitches().toList(): + l_switch.append(Switch(j_e)) + return l_switch + + def get_switch_count(self): + return self.j_instance.getSwitchCount() + + def get_load_count(self): + return self.j_instance.getLoadCount() + + def get_shunt_count(self): + return self.j_instance.getShuntCount() + + def get_shunt_compensators(self): + l_shuntcompensator = [] + for j_e in self.j_instance.getShuntCompensators().toList(): + l_shuntcompensator.append(ShuntCompensator(j_e)) + return l_shuntcompensator + + def get_shunt_compensator_count(self): + return self.j_instance.getShuntCompensatorCount() + + def get_dangling_lines(self): + l_danglingline = [] + for j_e in self.j_instance.getDanglingLines().toList(): + l_danglingline.append(DanglingLine(j_e)) + return l_danglingline + + def get_dangling_line_count(self): + return self.j_instance.getDanglingLineCount() + + def get_static_var_compensators(self): + l_staticvarcompensator = [] + for j_e in self.j_instance.getStaticVarCompensators().toList(): + l_staticvarcompensator.append(StaticVarCompensator(j_e)) + return l_staticvarcompensator + + def get_static_var_compensator_count(self): + return self.j_instance.getStaticVarCompensatorCount() + + def get_vsc_converter_stations(self): + l_vscconverterstation = [] + for j_e in self.j_instance.getVscConverterStations().toList(): + l_vscconverterstation.append(VscConverterStation(j_e)) + return l_vscconverterstation + + def get_vsc_converter_station_count(self): + return self.j_instance.getVscConverterStationCount() + + def get_lcc_converter_stations(self): + l_lccconverterstation = [] + for j_e in self.j_instance.getLccConverterStations().toList(): + l_lccconverterstation.append(LccConverterStation(j_e)) + return l_lccconverterstation + + def get_substation(self): + return Substation(self.j_instance.getSubstation()) + + def get_nominal_v(self): + return self.j_instance.getNominalV() + + def get_low_voltage_limit(self): + return self.j_instance.getLowVoltageLimit() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.ShuntCompensator +class ShuntCompensator(Injection): + + def __init__(self, j_shuntcompensator): + Injection.__init__(self, j_shuntcompensator) + self.j_instance = j_shuntcompensator + + def get_current_b(self): + return self.j_instance.getCurrentB() + + def get_current_section_count(self): + return self.j_instance.getCurrentSectionCount() + + def get_maximum_b(self): + return self.j_instance.getMaximumB() + + def get_maximum_section_count(self): + return self.j_instance.getMaximumSectionCount() + + def get_b_per_section(self): + return self.j_instance.getbPerSection() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.StaticVarCompensator +class StaticVarCompensator(Injection): + + def __init__(self, j_staticvarcompensator): + Injection.__init__(self, j_staticvarcompensator) + self.j_instance = j_staticvarcompensator + + def get_bmax(self): + return self.j_instance.getBmax() + + def get_bmin(self): + return self.j_instance.getBmin() + + def get_reactive_power_set_point(self): + return self.j_instance.getReactivePowerSetPoint() + + def get_voltage_set_point(self): + return self.j_instance.getVoltageSetPoint() + + +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Switch +class Switch(Identifiable): + + def __init__(self, j_switch): + Identifiable.__init__(self, j_switch) + self.j_instance = j_switch + + def get_voltage_level(self): + return VoltageLevel(self.j_instance.getVoltageLevel()) + + def is_fictitious(self): + return self.j_instance.isFictitious() + + def is_open(self): + return self.j_instance.isOpen() + + def is_retained(self): + return self.j_instance.isRetained() + + def set_fictitious(self, var0): + self.j_instance.setFictitious(var0) + + def set_open(self, var0): + self.j_instance.setOpen(var0) + + def set_retained(self, var0): + self.j_instance.setRetained(var0) + + +############ ENUM ############## + +class ConnectableType(Enum): + BUSBAR_SECTION = 'BUSBAR_SECTION' + LINE = 'LINE' + TWO_WINDINGS_TRANSFORMER = 'TWO_WINDINGS_TRANSFORMER' + THREE_WINDINGS_TRANSFORMER = 'THREE_WINDINGS_TRANSFORMER' + GENERATOR = 'GENERATOR' + LOAD = 'LOAD' + SHUNT_COMPENSATOR = 'SHUNT_COMPENSATOR' + DANGLING_LINE = 'DANGLING_LINE' + STATIC_VAR_COMPENSATOR = 'STATIC_VAR_COMPENSATOR' + HVDC_CONVERTER_STATION = 'HVDC_CONVERTER_STATION' diff --git a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java new file mode 100644 index 00000000..2d1ef30e --- /dev/null +++ b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java @@ -0,0 +1,265 @@ +/** + * Copyright (c) 2018, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package com.powsybl.powsybl; + +import com.powsybl.iidm.network.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Method; +import java.util.*; +import java.util.stream.Collectors; + +/** + * @author Yichen TANG + */ +public final class PythonCodeGenerator { + + private static final Logger LOGGER = LoggerFactory.getLogger(PythonCodeGenerator.class); + + private static final Set SIMPLE_TYPE = new HashSet<>(Arrays.asList("int", "boolean", "float", "double", "long", "class java.lang.String")); + private static final Set SKIP_METHODS_NAME = new HashSet<>(Arrays.asList("export", "merge", "visit", "remove")); + private static final String BLANK_LINE = ""; + private static final String A1_DEF = " def "; + private static final String A2_RETURN = " return "; + private static final String A2 = " "; + private static final String A3 = " "; + private static final String SELF_ARG = "(self):"; + + private PythonCodeGenerator() { + + } + + public static void main(String... args) { +// Class clazz = Bus.class; +// Class clazz = Branch.class; +// Class clazz = Component.class; +// Class clazz = Connectable.class; +// Class clazz = Container.class; +// Class clazz = CurrentLimits.class; +// Class clazz = DanglingLine.class; +// Class clazz = LccConverterStation.class; +// Class clazz = Line.class; +// Class clazz = Generator.class; +// Class clazz = HvdcConverterStation.class; +// Class clazz = HvdcLine.class; +// Class clazz = Load.class; +// Class clazz = Network.class; +// Class clazz = ReactiveLimits.class; +// Class clazz = ShuntCompensator.class; +// Class clazz = StaticVarCompensator.class; +// Class clazz = Switch.class; +// Class clazz = Terminal.class; +// Class clazz = ThreeWindingsTransformer.class; +// Class clazz = TwoWindingsTransformer.class; +// Class clazz = VoltageLevel.class; + Class clazz = VscConverterStation.class; + + List superInterfaces = Arrays.asList(clazz.getInterfaces()); + System.out.println("----super interfaces----"); + for (Class c : superInterfaces) { + System.out.println(c); + } + + + List codes = new ArrayList<>(); + codes.add("# Auto generated python wrapper for java class: " + clazz.getCanonicalName()); + if (clazz.getSuperclass() == null && superInterfaces.isEmpty()) { + codes.add("class " + clazz.getSimpleName() + ":"); + codes.add(BLANK_LINE); + String arg = "j_" + clazz.getSimpleName().toLowerCase(); + codes.add(A1_DEF + "__init__(self, " + arg + "):"); + codes.add(A2 + "self.j_instance = " + arg); + } else { + String superClazz = superInterfaces.get(0).getSimpleName(); + if (superClazz.equals("Container")) { + superClazz = "Identifiable"; + } + codes.add("class " + clazz.getSimpleName() + "(" + superClazz + "):"); + codes.add(BLANK_LINE); + String arg = "j_" + clazz.getSimpleName().toLowerCase(); + codes.add(A1_DEF + "__init__(self, " + arg + "):"); + codes.add(A2 + superClazz + ".__init__(self, " + arg + ")"); + codes.add(A2 + "self.j_instance = " + arg); + } + codes.add(BLANK_LINE); + + + List methods = Arrays.asList(clazz.getMethods()); + methods.stream().sorted(Comparator.comparing(Method::getName) + ).collect(Collectors.toList()).stream().sequential().forEach(m -> { + String methodName = m.getName(); + if (!skip(m, clazz)) { + String returnType = m.getReturnType().toString(); + if (SIMPLE_TYPE.contains(returnType)) { + codes.add(A1_DEF + to_python_style(methodName) + argsDef(m)); + codes.add(A2_RETURN + "self.j_instance." + methodName + argsInvocation(m)); + codes.add(BLANK_LINE); + } else if (returnType.equals("interface java.lang.Iterable")) { + codes.add(A1_DEF + to_python_style(methodName) + SELF_ARG); + String eleClazzName = getReturnElementClassName(methodName); + String eleListVar = "l_" + eleClazzName.toLowerCase(); + codes.add(A2 + eleListVar + " = []"); + codes.add(A2 + "for j_e in self.j_instance." + methodName + "().toList():"); + + codes.add(A3 + eleListVar + ".append(" + eleClazzName + "(j_e))"); + codes.add(A2_RETURN + eleListVar); + codes.add(BLANK_LINE); + } else if (returnType.equals("interface java.util.List")) { + codes.add(A1_DEF + to_python_style(methodName) + argsDef(m)); + String eleClazzName = getReturnElementClassName(methodName); + String eleListVar = "l_" + eleClazzName.toLowerCase(); + codes.add(A2 + eleListVar + " = []"); + codes.add(A2 + "for j_e in self.j_instance." + methodName + argsInvocation(m) + ":"); + + codes.add(A3 + eleListVar + ".append(" + eleClazzName + "(j_e))"); + codes.add(A2_RETURN + eleListVar); + codes.add(BLANK_LINE); + } else if (returnType.startsWith("interface com.powsybl.iidm.network")) { + String returnTypeSimpleName = m.getReturnType().getSimpleName(); + if (!skipByReturnType(m)) { + codes.add(A1_DEF + to_python_style(methodName) + argsDef(m)); + codes.add(A2_RETURN + returnTypeSimpleName + "(self.j_instance." + methodName + argsInvocation(m) + ")"); + codes.add(BLANK_LINE); + } + } else if (returnType.equals("void")) { + codes.add(A1_DEF + to_python_style(methodName) + argsDef(m)); + codes.add(A2 + "self.j_instance." + methodName + argsInvocation(m)); + codes.add(BLANK_LINE); + } else { + System.out.println(returnType); + System.out.println(m + " not implemented".toUpperCase()); + } + } + }); + System.out.println("-------------------------"); + codes.stream().forEach(l -> System.out.println(l)); + } + + static String argsDef(Method m) { + List classes = Arrays.asList(m.getParameterTypes()); + if (classes.isEmpty()) { + return SELF_ARG; + } else { + String paras = "(self,"; + for (int i = 0; i < classes.size() - 1; i++) { + paras += " var" + i + ","; + } + paras += " var" + (classes.size() - 1) + "):"; + return paras; + } + } + + static String argsInvocation(Method m) { + List classes = Arrays.asList(m.getParameterTypes()); + if (classes.isEmpty()) { + return "()"; + } else { + if (classes.size() == 1) { + return "(var0)"; + } + String paras = "("; + for (int i = 0; i < classes.size() - 1; i++) { + paras += " var" + i + ","; + } + paras += " var" + (classes.size() - 1) + ")"; + return paras; + } + } + + static String getReturnElementClassName(String methodName) { + System.out.println(methodName); + String returnElementName = methodName.substring(3); + String removeS = returnElementName.substring(0, returnElementName.length() - 1); + if (removeS.equals("Buse") || removeS.equals("Switche") || removeS.equals("Branche")) { + return returnElementName.substring(0, returnElementName.length() - 2); + } + if (removeS.equals("Shunt")) { + return "ShuntCompensator"; + } + return removeS; + } + + static boolean skipByReturnType(Method m) { + String returnTypeSimpleName = m.getReturnType().getSimpleName(); + if (m.getReturnType().toString().contains("$")) { + System.out.println(m + " TODO nested class"); + return true; + } + if (returnTypeSimpleName.endsWith("TapChanger")) { + System.out.println(m + " TODO tapchanger"); + return true; + } + if (returnTypeSimpleName.endsWith("StateManager")) { + System.out.println(m + " TODO StateManager"); + return true; + } + return false; + } + + static boolean skip(Method m, Class clazz) { + String methodName = m.getName(); + List annotations = Arrays.asList(m.getDeclaredAnnotations()); + for (Annotation anno : annotations) { + if (anno.annotationType().getSimpleName().equals("Deprecated")) { + System.out.println(m + " skipped(Deprecated)"); + return true; + } + } + if (methodName.startsWith("new")) { + System.out.println(m + " skipped(new)"); + return true; + } + if (methodName.endsWith("Stream")) { + System.out.println(m + " skipped(Stream)"); + return true; + } + if (methodName.startsWith("set") && !clazz.getSimpleName().equals("Switch")) { + System.out.println(m + " skipped(set)"); + return true; + } + List parameterClass = Arrays.asList(m.getParameterTypes()); + for (Class c : parameterClass) { + if (c.getSimpleName().equals("Class") || c.getSimpleName().equals("Country")) { + System.out.println(m + " skipped(parameters with class)"); + return true; + } + } + for (String mn : SKIP_METHODS_NAME) { + if (methodName.startsWith(mn)) { + System.out.println(m + " skipped(mapbe to implement later)"); + return true; + } + } + + List superInterfaces = Arrays.asList(clazz.getInterfaces()); + if (!superInterfaces.isEmpty()) { + List methodsInSuperClass = Arrays.asList(superInterfaces.get(0).getMethods()); + if (methodsInSuperClass.contains(m)) { + System.out.println(m + " skipped(super method)"); + return true; + } + } + return false; + } + + static String to_python_style(String javaMethodName) { + if (javaMethodName.equals("getbPerSection")) { + return "get_b_per_section"; + } + String[] r = javaMethodName.split("(?=\\p{Upper})"); +// Arrays.asList(r).stream().forEach(l -> System.out.println(l)); + String python = ""; + for (int i = 0; i < r.length - 1; i++) { + python = python + r[i].toLowerCase() + "_"; + } + python = python + r[r.length - 1].toLowerCase(); + return python; + } + +} From 90c4b06c7a384ecbbcd418883e15655779e786d4 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Tue, 4 Dec 2018 10:29:18 +0100 Subject: [PATCH 07/14] Small fix --- py-powsybl/pypowsybl/__init__.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 767e2a24..3df44833 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -23,6 +23,7 @@ retried = 0 + def launch_task(config_name, nb_port): if config_name is None: cmd = 'itools py-powsybl -port=' + str(nb_port) @@ -67,7 +68,7 @@ def connect(nb_port): default_exporter_properties = gateway.jvm.java.util.Properties() # needed below to resolve some class-factories, by name - ReflectionUtil = gateway.jvm.py4j.reflection.ReflectionUtil + reflection_util = gateway.jvm.py4j.reflection.ReflectionUtil # load platform config global defaultConfig @@ -77,7 +78,7 @@ def connect(nb_port): global computation_manager computation_manager = gateway.jvm.LocalComputationManager() global lf_factory - lf_factory = defaultConfig.newFactoryImpl(ReflectionUtil.classForName("com.powsybl.loadflow.LoadFlowFactory")) + lf_factory = defaultConfig.newFactoryImpl(reflection_util.classForName("com.powsybl.loadflow.LoadFlowFactory")) global lf_para lf_para = gateway.jvm.com.powsybl.loadflow.LoadFlowParameters.load() global importer From 1cb3e07b9315f9a5b8deaf8c14acb13052a0f337 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Tue, 4 Dec 2018 11:27:01 +0100 Subject: [PATCH 08/14] Add more branch/busbarsection method --- py-powsybl/README.md | 5 ++- py-powsybl/pypowsybl/__init__.py | 45 +++++++++++++++---- .../powsybl/powsybl/PythonCodeGenerator.java | 8 ++-- 3 files changed, 46 insertions(+), 12 deletions(-) diff --git a/py-powsybl/README.md b/py-powsybl/README.md index 6c6283c2..f7b70190 100644 --- a/py-powsybl/README.md +++ b/py-powsybl/README.md @@ -38,7 +38,10 @@ def dump_lines_flow(network): print(len(network.get_lines())) for l in network.get_lines(): print(l.get_id() + ";" + str(l.get_terminal_1().get_i()) + ";" + str(l.get_terminal_2().get_i())) - + print(l.get_current_limits_1().get_permanent_limit()) + print(str(l.check_permanent_limit_1()) + ";" + str(l.check_permanent_limit_2())) + print(str(l.check_permanent_limit_1(0.1)) + ";" + str(l.check_permanent_limit_2(0.1))) + print(str(l.is_overloaded()) + ";" + str(l.is_overloaded(0.1))) if __name__ == '__main__': port = 3338 diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 3df44833..4ae5afce 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -426,14 +426,36 @@ def get_terminal(self): return Terminal(self.j_instance.getTerminal()) +# Auto generated python wrapper for java class: com.powsybl.iidm.network.Branch class Branch(Connectable): def __init__(self, j_branch): Connectable.__init__(self, j_branch) self.j_instance = j_branch - def is_overloaded(self): - return self.j_instance.isOverloaded() + def check_permanent_limit_1(self, var0=None): + if var0 is None: + return self.j_instance.checkPermanentLimit1() + else: + return self.j_instance.checkPermanentLimit1(var0) + + def check_permanent_limit_2(self, var0=None): + if var0 is None: + return self.j_instance.checkPermanentLimit2() + else: + return self.j_instance.checkPermanentLimit2(var0) + + def get_current_limits_1(self): + return CurrentLimits(self.j_instance.getCurrentLimits1()) + + def get_current_limits_2(self): + return CurrentLimits(self.j_instance.getCurrentLimits2()) + + def get_overload_duration(self): + return self.j_instance.getOverloadDuration() + + def get_terminal(self, var0): + return Terminal(self.j_instance.getTerminal(var0)) def get_terminal_1(self): return Terminal(self.j_instance.getTerminal1()) @@ -441,6 +463,12 @@ def get_terminal_1(self): def get_terminal_2(self): return Terminal(self.j_instance.getTerminal2()) + def is_overloaded(self, var0=None): + if var0 is None: + return self.j_instance.isOverloaded() + else: + return self.j_instance.isOverloaded(var0) + # Auto generated python wrapper for java class: com.powsybl.iidm.network.Bus class Bus(Identifiable): @@ -843,18 +871,19 @@ def get_substation(self): return Substation(self.j_instance.getSubstation()) +# Auto generated python wrapper for java class: com.powsybl.iidm.network.BusbarSection class BusbarSection(Injection): - def __init__(self, j_busbar_section): - Injection.__init__(self, j_busbar_section) - self.j_instance = j_busbar_section - - def get_v(self): - return self.j_instance.getV() + def __init__(self, j_busbarsection): + Injection.__init__(self, j_busbarsection) + self.j_instance = j_busbarsection def get_angle(self): return self.j_instance.getAngle() + def get_v(self): + return self.j_instance.getV() + # Auto generated python wrapper for java class: com.powsybl.iidm.network.VoltageLevel # TODO container diff --git a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java index 2d1ef30e..86dd9924 100644 --- a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java +++ b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java @@ -24,6 +24,7 @@ public final class PythonCodeGenerator { private static final Set SIMPLE_TYPE = new HashSet<>(Arrays.asList("int", "boolean", "float", "double", "long", "class java.lang.String")); private static final Set SKIP_METHODS_NAME = new HashSet<>(Arrays.asList("export", "merge", "visit", "remove")); + private static final Set SKIP_PARA_TYPE = new HashSet<>(Arrays.asList("Country", "Side", "Class")); private static final String BLANK_LINE = ""; private static final String A1_DEF = " def "; private static final String A2_RETURN = " return "; @@ -38,6 +39,7 @@ private PythonCodeGenerator() { public static void main(String... args) { // Class clazz = Bus.class; // Class clazz = Branch.class; +// Class clazz = BusbarSection.class; // Class clazz = Component.class; // Class clazz = Connectable.class; // Class clazz = Container.class; @@ -225,8 +227,8 @@ static boolean skip(Method m, Class clazz) { } List parameterClass = Arrays.asList(m.getParameterTypes()); for (Class c : parameterClass) { - if (c.getSimpleName().equals("Class") || c.getSimpleName().equals("Country")) { - System.out.println(m + " skipped(parameters with class)"); + if (SKIP_PARA_TYPE.contains(c.getSimpleName())) { + System.out.println(m + " skipped(parameters type)"); return true; } } @@ -252,7 +254,7 @@ static String to_python_style(String javaMethodName) { if (javaMethodName.equals("getbPerSection")) { return "get_b_per_section"; } - String[] r = javaMethodName.split("(?=\\p{Upper})"); + String[] r = javaMethodName.split("(?=\\p{Upper}|\\d)"); // Arrays.asList(r).stream().forEach(l -> System.out.println(l)); String python = ""; for (int i = 0; i < r.length - 1; i++) { From bd06e6322ee909a9d9738ff3eb0d2c9fcacfbb96 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Tue, 4 Dec 2018 12:31:28 +0100 Subject: [PATCH 09/14] Use toArray() in case of jvm return immutable collection --- py-powsybl/pypowsybl/__init__.py | 74 +++++++++---------- .../powsybl/powsybl/PythonCodeGenerator.java | 2 +- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 4ae5afce..2b5e59e9 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -156,7 +156,7 @@ def get_branch_count(self): def get_branches(self): l_branch = [] - for j_e in self.j_instance.getBranches().toList(): + for j_e in self.j_instance.getBranches().toArray(): l_branch.append(Branch(j_e)) return l_branch @@ -168,7 +168,7 @@ def get_busbar_section_count(self): def get_busbar_sections(self): l_busbarsection = [] - for j_e in self.j_instance.getBusbarSections().toList(): + for j_e in self.j_instance.getBusbarSections().toArray(): l_busbarsection.append(BusbarSection(j_e)) return l_busbarsection @@ -183,7 +183,7 @@ def get_dangling_line_count(self): def get_dangling_lines(self): l_danglingline = [] - for j_e in self.j_instance.getDanglingLines().toList(): + for j_e in self.j_instance.getDanglingLines().toArray(): l_danglingline.append(DanglingLine(j_e)) return l_danglingline @@ -198,7 +198,7 @@ def get_generator_count(self): def get_generators(self): l_generator = [] - for j_e in self.j_instance.getGenerators().toList(): + for j_e in self.j_instance.getGenerators().toArray(): l_generator.append(Generator(j_e)) return l_generator @@ -210,7 +210,7 @@ def get_hvdc_converter_station_count(self): def get_hvdc_converter_stations(self): l_hvdcconverterstation = [] - for j_e in self.j_instance.getHvdcConverterStations().toList(): + for j_e in self.j_instance.getHvdcConverterStations().toArray(): l_hvdcconverterstation.append(HvdcConverterStation(j_e)) return l_hvdcconverterstation @@ -222,7 +222,7 @@ def get_hvdc_line_count(self): def get_hvdc_lines(self): l_hvdcline = [] - for j_e in self.j_instance.getHvdcLines().toList(): + for j_e in self.j_instance.getHvdcLines().toArray(): l_hvdcline.append(HvdcLine(j_e)) return l_hvdcline @@ -237,7 +237,7 @@ def get_lcc_converter_station_count(self): def get_lcc_converter_stations(self): l_lccconverterstation = [] - for j_e in self.j_instance.getLccConverterStations().toList(): + for j_e in self.j_instance.getLccConverterStations().toArray(): l_lccconverterstation.append(LccConverterStation(j_e)) return l_lccconverterstation @@ -249,7 +249,7 @@ def get_line_count(self): def get_lines(self): l_line = [] - for j_e in self.j_instance.getLines().toList(): + for j_e in self.j_instance.getLines().toArray(): l_line.append(Line(j_e)) return l_line @@ -261,7 +261,7 @@ def get_load_count(self): def get_loads(self): l_load = [] - for j_e in self.j_instance.getLoads().toList(): + for j_e in self.j_instance.getLoads().toArray(): l_load.append(Load(j_e)) return l_load @@ -273,7 +273,7 @@ def get_shunt_count(self): def get_shunts(self): l_shuntcompensator = [] - for j_e in self.j_instance.getShunts().toList(): + for j_e in self.j_instance.getShunts().toArray(): l_shuntcompensator.append(ShuntCompensator(j_e)) return l_shuntcompensator @@ -288,7 +288,7 @@ def get_static_var_compensator_count(self): def get_static_var_compensators(self): l_staticvarcompensator = [] - for j_e in self.j_instance.getStaticVarCompensators().toList(): + for j_e in self.j_instance.getStaticVarCompensators().toArray(): l_staticvarcompensator.append(StaticVarCompensator(j_e)) return l_staticvarcompensator @@ -300,7 +300,7 @@ def get_substation_count(self): def get_substations(self): l_substation = [] - for j_e in self.j_instance.getSubstations().toList(): + for j_e in self.j_instance.getSubstations().toArray(): l_substation.append(Substation(j_e)) return l_substation @@ -312,7 +312,7 @@ def get_switch_count(self): def get_switches(self): l_switch = [] - for j_e in self.j_instance.getSwitches().toList(): + for j_e in self.j_instance.getSwitches().toArray(): l_switch.append(Switch(j_e)) return l_switch @@ -324,7 +324,7 @@ def get_three_windings_transformer_count(self): def get_three_windings_transformers(self): l_threewindingstransformer = [] - for j_e in self.j_instance.getThreeWindingsTransformers().toList(): + for j_e in self.j_instance.getThreeWindingsTransformers().toArray(): l_threewindingstransformer.append(ThreeWindingsTransformer(j_e)) return l_threewindingstransformer @@ -336,7 +336,7 @@ def get_two_windings_transformer_count(self): def get_two_windings_transformers(self): l_twowindingstransformer = [] - for j_e in self.j_instance.getTwoWindingsTransformers().toList(): + for j_e in self.j_instance.getTwoWindingsTransformers().toArray(): l_twowindingstransformer.append(TwoWindingsTransformer(j_e)) return l_twowindingstransformer @@ -348,7 +348,7 @@ def get_voltage_level_count(self): def get_voltage_levels(self): l_voltagelevel = [] - for j_e in self.j_instance.getVoltageLevels().toList(): + for j_e in self.j_instance.getVoltageLevels().toArray(): l_voltagelevel.append(VoltageLevel(j_e)) return l_voltagelevel @@ -360,7 +360,7 @@ def get_vsc_converter_station_count(self): def get_vsc_converter_stations(self): l_vscconverterstation = [] - for j_e in self.j_instance.getVscConverterStations().toList(): + for j_e in self.j_instance.getVscConverterStations().toArray(): l_vscconverterstation.append(VscConverterStation(j_e)) return l_vscconverterstation @@ -488,31 +488,31 @@ def get_connected_terminal_count(self): def get_dangling_lines(self): l_danglingline = [] - for j_e in self.j_instance.getDanglingLines().toList(): + for j_e in self.j_instance.getDanglingLines().toArray(): l_danglingline.append(DanglingLine(j_e)) return l_danglingline def get_generators(self): l_generator = [] - for j_e in self.j_instance.getGenerators().toList(): + for j_e in self.j_instance.getGenerators().toArray(): l_generator.append(Generator(j_e)) return l_generator def get_lcc_converter_stations(self): l_lccconverterstation = [] - for j_e in self.j_instance.getLccConverterStations().toList(): + for j_e in self.j_instance.getLccConverterStations().toArray(): l_lccconverterstation.append(LccConverterStation(j_e)) return l_lccconverterstation def get_lines(self): l_line = [] - for j_e in self.j_instance.getLines().toList(): + for j_e in self.j_instance.getLines().toArray(): l_line.append(Line(j_e)) return l_line def get_loads(self): l_load = [] - for j_e in self.j_instance.getLoads().toList(): + for j_e in self.j_instance.getLoads().toArray(): l_load.append(Load(j_e)) return l_load @@ -524,13 +524,13 @@ def get_q(self): def get_shunt_compensators(self): l_shuntcompensator = [] - for j_e in self.j_instance.getShuntCompensators().toList(): + for j_e in self.j_instance.getShuntCompensators().toArray(): l_shuntcompensator.append(ShuntCompensator(j_e)) return l_shuntcompensator def get_static_var_compensators(self): l_staticvarcompensator = [] - for j_e in self.j_instance.getStaticVarCompensators().toList(): + for j_e in self.j_instance.getStaticVarCompensators().toArray(): l_staticvarcompensator.append(StaticVarCompensator(j_e)) return l_staticvarcompensator @@ -539,13 +539,13 @@ def get_synchronous_component(self): def get_three_windings_transformers(self): l_threewindingtransformer = [] - for j_e in self.j_instance.getThreeWindingsTransformers().toList(): + for j_e in self.j_instance.getThreeWindingsTransformers().toArray(): l_threewindingtransformer.append(ThreeWindingsTransformer(j_e)) return l_threewindingtransformer def get_two_windings_transformers(self): l_twowindingtransformer = [] - for j_e in self.j_instance.getTwoWindingsTransformers().toList(): + for j_e in self.j_instance.getTwoWindingsTransformers().toArray(): l_twowindingtransformer.append(TwoWindingsTransformer(j_e)) return l_twowindingtransformer @@ -557,7 +557,7 @@ def get_voltage_level(self): def get_vsc_converter_stations(self): l_vscconverterstation = [] - for j_e in self.j_instance.getVscConverterStations().toList(): + for j_e in self.j_instance.getVscConverterStations().toArray(): l_vscconverterstation.append(VscConverterStation(j_e)) return l_vscconverterstation @@ -579,7 +579,7 @@ def get_num(self): def get_buses(self): l_bus = [] - for j_e in self.j_instance.getBuses().toList(): + for j_e in self.j_instance.getBuses().toArray(): l_bus.append(Bus(j_e)) return l_bus @@ -898,7 +898,7 @@ def get_high_voltage_limit(self): def get_connectables(self): l_connectable = [] - for j_e in self.j_instance.getConnectables().toList(): + for j_e in self.j_instance.getConnectables().toArray(): l_connectable.append(Connectable(j_e)) return l_connectable @@ -910,7 +910,7 @@ def get_connectable_count(self): def get_generators(self): l_generator = [] - for j_e in self.j_instance.getGenerators().toList(): + for j_e in self.j_instance.getGenerators().toArray(): l_generator.append(Generator(j_e)) return l_generator @@ -919,13 +919,13 @@ def get_generator_count(self): def get_loads(self): l_load = [] - for j_e in self.j_instance.getLoads().toList(): + for j_e in self.j_instance.getLoads().toArray(): l_load.append(Load(j_e)) return l_load def get_switches(self): l_switch = [] - for j_e in self.j_instance.getSwitches().toList(): + for j_e in self.j_instance.getSwitches().toArray(): l_switch.append(Switch(j_e)) return l_switch @@ -940,7 +940,7 @@ def get_shunt_count(self): def get_shunt_compensators(self): l_shuntcompensator = [] - for j_e in self.j_instance.getShuntCompensators().toList(): + for j_e in self.j_instance.getShuntCompensators().toArray(): l_shuntcompensator.append(ShuntCompensator(j_e)) return l_shuntcompensator @@ -949,7 +949,7 @@ def get_shunt_compensator_count(self): def get_dangling_lines(self): l_danglingline = [] - for j_e in self.j_instance.getDanglingLines().toList(): + for j_e in self.j_instance.getDanglingLines().toArray(): l_danglingline.append(DanglingLine(j_e)) return l_danglingline @@ -958,7 +958,7 @@ def get_dangling_line_count(self): def get_static_var_compensators(self): l_staticvarcompensator = [] - for j_e in self.j_instance.getStaticVarCompensators().toList(): + for j_e in self.j_instance.getStaticVarCompensators().toArray(): l_staticvarcompensator.append(StaticVarCompensator(j_e)) return l_staticvarcompensator @@ -967,7 +967,7 @@ def get_static_var_compensator_count(self): def get_vsc_converter_stations(self): l_vscconverterstation = [] - for j_e in self.j_instance.getVscConverterStations().toList(): + for j_e in self.j_instance.getVscConverterStations().toArray(): l_vscconverterstation.append(VscConverterStation(j_e)) return l_vscconverterstation @@ -976,7 +976,7 @@ def get_vsc_converter_station_count(self): def get_lcc_converter_stations(self): l_lccconverterstation = [] - for j_e in self.j_instance.getLccConverterStations().toList(): + for j_e in self.j_instance.getLccConverterStations().toArray(): l_lccconverterstation.append(LccConverterStation(j_e)) return l_lccconverterstation diff --git a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java index 86dd9924..64238c18 100644 --- a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java +++ b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java @@ -107,7 +107,7 @@ public static void main(String... args) { String eleClazzName = getReturnElementClassName(methodName); String eleListVar = "l_" + eleClazzName.toLowerCase(); codes.add(A2 + eleListVar + " = []"); - codes.add(A2 + "for j_e in self.j_instance." + methodName + "().toList():"); + codes.add(A2 + "for j_e in self.j_instance." + methodName + "().toArray():"); codes.add(A3 + eleListVar + ".append(" + eleClazzName + "(j_e))"); codes.add(A2_RETURN + eleListVar); From 9123427eba544e4dd763952bf098a66c75bc848e Mon Sep 17 00:00:00 2001 From: yichen88 Date: Tue, 4 Dec 2018 12:33:23 +0100 Subject: [PATCH 10/14] Small fix --- py-powsybl/pypowsybl/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 2b5e59e9..9ebff7be 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -59,7 +59,6 @@ def connect(nb_port): java_import(gateway.jvm, 'com.powsybl.loadflow.LoadFlowFactory') java_import(gateway.jvm, 'com.powsybl.iidm.import_.Importers') java_import(gateway.jvm, 'com.powsybl.iidm.export.Exporters') - java_import(gateway.jvm, 'com.powsybl.iidm.network.test.FictitiousSwitchFactory') global string_class string_class = gateway.jvm.java.lang.String From 44fd0fee7df4850a2eafd69f4f9798bd710ba7ac Mon Sep 17 00:00:00 2001 From: yichen88 Date: Thu, 6 Dec 2018 14:15:22 +0100 Subject: [PATCH 11/14] toArray or toList depends on methods name --- py-powsybl/pypowsybl/__init__.py | 8 ++++---- .../powsybl/powsybl/PythonCodeGenerator.java | 18 +++++++++++++++--- 2 files changed, 19 insertions(+), 7 deletions(-) diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 9ebff7be..0293a5f0 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -155,7 +155,7 @@ def get_branch_count(self): def get_branches(self): l_branch = [] - for j_e in self.j_instance.getBranches().toArray(): + for j_e in self.j_instance.getBranches().toList(): l_branch.append(Branch(j_e)) return l_branch @@ -209,7 +209,7 @@ def get_hvdc_converter_station_count(self): def get_hvdc_converter_stations(self): l_hvdcconverterstation = [] - for j_e in self.j_instance.getHvdcConverterStations().toArray(): + for j_e in self.j_instance.getHvdcConverterStations().toList(): l_hvdcconverterstation.append(HvdcConverterStation(j_e)) return l_hvdcconverterstation @@ -248,7 +248,7 @@ def get_line_count(self): def get_lines(self): l_line = [] - for j_e in self.j_instance.getLines().toArray(): + for j_e in self.j_instance.getLines().toList(): l_line.append(Line(j_e)) return l_line @@ -347,7 +347,7 @@ def get_voltage_level_count(self): def get_voltage_levels(self): l_voltagelevel = [] - for j_e in self.j_instance.getVoltageLevels().toArray(): + for j_e in self.j_instance.getVoltageLevels().toList(): l_voltagelevel.append(VoltageLevel(j_e)) return l_voltagelevel diff --git a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java index 64238c18..e7ca0ebd 100644 --- a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java +++ b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java @@ -25,6 +25,8 @@ public final class PythonCodeGenerator { private static final Set SIMPLE_TYPE = new HashSet<>(Arrays.asList("int", "boolean", "float", "double", "long", "class java.lang.String")); private static final Set SKIP_METHODS_NAME = new HashSet<>(Arrays.asList("export", "merge", "visit", "remove")); private static final Set SKIP_PARA_TYPE = new HashSet<>(Arrays.asList("Country", "Side", "Class")); + private static final Set MUTABLE_COLLECTIONS_METHOD = new HashSet<>(Arrays.asList("getBranches", "getLines", "getHvdcConverterStations", "getVoltageLevels")); + private static final String BLANK_LINE = ""; private static final String A1_DEF = " def "; private static final String A2_RETURN = " return "; @@ -51,7 +53,7 @@ public static void main(String... args) { // Class clazz = HvdcConverterStation.class; // Class clazz = HvdcLine.class; // Class clazz = Load.class; -// Class clazz = Network.class; + Class clazz = Network.class; // Class clazz = ReactiveLimits.class; // Class clazz = ShuntCompensator.class; // Class clazz = StaticVarCompensator.class; @@ -60,7 +62,7 @@ public static void main(String... args) { // Class clazz = ThreeWindingsTransformer.class; // Class clazz = TwoWindingsTransformer.class; // Class clazz = VoltageLevel.class; - Class clazz = VscConverterStation.class; +// Class clazz = VscConverterStation.class; List superInterfaces = Arrays.asList(clazz.getInterfaces()); System.out.println("----super interfaces----"); @@ -107,7 +109,7 @@ public static void main(String... args) { String eleClazzName = getReturnElementClassName(methodName); String eleListVar = "l_" + eleClazzName.toLowerCase(); codes.add(A2 + eleListVar + " = []"); - codes.add(A2 + "for j_e in self.j_instance." + methodName + "().toArray():"); + codes.add(A2 + pythonForStatement(methodName, clazz)); codes.add(A3 + eleListVar + ".append(" + eleClazzName + "(j_e))"); codes.add(A2_RETURN + eleListVar); @@ -143,6 +145,16 @@ public static void main(String... args) { codes.stream().forEach(l -> System.out.println(l)); } + // TODO init a real network in jvm and check instance type + static String pythonForStatement(String methodName, Class c) { + String collection = "Array"; + // TODO Bus.getFoos() + if (c.getSimpleName().equals("Network") && MUTABLE_COLLECTIONS_METHOD.contains(methodName)) { + collection = "List"; + } + return "for j_e in self.j_instance." + methodName + "().to" + collection + "():"; + } + static String argsDef(Method m) { List classes = Arrays.asList(m.getParameterTypes()); if (classes.isEmpty()) { From d4f0828d0e083dabdf5faec61a5fe9a417a0580f Mon Sep 17 00:00:00 2001 From: yichen88 Date: Thu, 6 Dec 2018 14:18:58 +0100 Subject: [PATCH 12/14] Fix typo --- py-powsybl/README.md | 4 ++-- py-powsybl/pypowsybl/__init__.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/py-powsybl/README.md b/py-powsybl/README.md index f7b70190..b46048a1 100644 --- a/py-powsybl/README.md +++ b/py-powsybl/README.md @@ -47,7 +47,7 @@ if __name__ == '__main__': port = 3338 launch("config2", port) if connect(port): - n1 = load("/path/to/case-file/example.xiidm") + n1 = load_network("/path/to/case-file/example.xiidm") dump_lines_flow(n1) lf = run_load_flow(n1) @@ -62,7 +62,7 @@ if __name__ == '__main__': # or save(n1, "/path/to/output/example.xiidm") # don't forget to shundown jvm - shundown_pypowsybl() + shutdown_pypowsybl() else: print("can not connect to jvm") diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index 0293a5f0..a22f55b5 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -94,7 +94,7 @@ def connect(nb_port): return False -def load(path): +def load_network(path): return Network(importer.loadNetwork(path)) @@ -124,7 +124,7 @@ def save(network, str_path): exporter.export(export_format, network.get_java_network(), default_exporter_properties, dest_path) -def shundown_pypowsybl(): +def shutdown_pypowsybl(): gateway.shutdown() From 323391e1252c1e3561a5e92578956f2b326cb7a5 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Thu, 6 Dec 2018 17:15:13 +0100 Subject: [PATCH 13/14] Fix jvm return iterable --- py-powsybl/pypowsybl/__init__.py | 81 ++++++++++--------- .../powsybl/powsybl/PythonCodeGenerator.java | 12 +-- 2 files changed, 46 insertions(+), 47 deletions(-) diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index a22f55b5..d992d479 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -23,6 +23,8 @@ retried = 0 +Lists = None + def launch_task(config_name, nb_port): if config_name is None: @@ -46,7 +48,7 @@ def connect(nb_port): global gateway try: time.sleep(1) - gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_field=True,port=nb_port)) + gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_field=True, port=nb_port)) # other boilerplate imports java_import(gateway.jvm, 'java.nio.file.Paths') @@ -59,6 +61,7 @@ def connect(nb_port): java_import(gateway.jvm, 'com.powsybl.loadflow.LoadFlowFactory') java_import(gateway.jvm, 'com.powsybl.iidm.import_.Importers') java_import(gateway.jvm, 'com.powsybl.iidm.export.Exporters') + java_import(gateway.jvm, 'com.google.common.collect.Lists') global string_class string_class = gateway.jvm.java.lang.String @@ -84,6 +87,8 @@ def connect(nb_port): importer = gateway.jvm.com.powsybl.iidm.import_.Importers global exporter exporter = gateway.jvm.com.powsybl.iidm.export.Exporters + global Lists + Lists = gateway.jvm.com.google.common.collect.Lists return True except Py4JError: global retried @@ -155,7 +160,7 @@ def get_branch_count(self): def get_branches(self): l_branch = [] - for j_e in self.j_instance.getBranches().toList(): + for j_e in Lists.newArrayList(self.j_instance.getBranches()): l_branch.append(Branch(j_e)) return l_branch @@ -167,7 +172,7 @@ def get_busbar_section_count(self): def get_busbar_sections(self): l_busbarsection = [] - for j_e in self.j_instance.getBusbarSections().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getBusbarSections()): l_busbarsection.append(BusbarSection(j_e)) return l_busbarsection @@ -182,7 +187,7 @@ def get_dangling_line_count(self): def get_dangling_lines(self): l_danglingline = [] - for j_e in self.j_instance.getDanglingLines().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getDanglingLines()): l_danglingline.append(DanglingLine(j_e)) return l_danglingline @@ -197,7 +202,7 @@ def get_generator_count(self): def get_generators(self): l_generator = [] - for j_e in self.j_instance.getGenerators().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getGenerators()): l_generator.append(Generator(j_e)) return l_generator @@ -209,7 +214,7 @@ def get_hvdc_converter_station_count(self): def get_hvdc_converter_stations(self): l_hvdcconverterstation = [] - for j_e in self.j_instance.getHvdcConverterStations().toList(): + for j_e in Lists.newArrayList(self.j_instance.getHvdcConverterStations()): l_hvdcconverterstation.append(HvdcConverterStation(j_e)) return l_hvdcconverterstation @@ -221,7 +226,7 @@ def get_hvdc_line_count(self): def get_hvdc_lines(self): l_hvdcline = [] - for j_e in self.j_instance.getHvdcLines().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getHvdcLines()): l_hvdcline.append(HvdcLine(j_e)) return l_hvdcline @@ -236,7 +241,7 @@ def get_lcc_converter_station_count(self): def get_lcc_converter_stations(self): l_lccconverterstation = [] - for j_e in self.j_instance.getLccConverterStations().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getLccConverterStations()): l_lccconverterstation.append(LccConverterStation(j_e)) return l_lccconverterstation @@ -248,7 +253,7 @@ def get_line_count(self): def get_lines(self): l_line = [] - for j_e in self.j_instance.getLines().toList(): + for j_e in Lists.newArrayList(self.j_instance.getLines()): l_line.append(Line(j_e)) return l_line @@ -260,7 +265,7 @@ def get_load_count(self): def get_loads(self): l_load = [] - for j_e in self.j_instance.getLoads().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getLoads()): l_load.append(Load(j_e)) return l_load @@ -272,7 +277,7 @@ def get_shunt_count(self): def get_shunts(self): l_shuntcompensator = [] - for j_e in self.j_instance.getShunts().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getShunts()): l_shuntcompensator.append(ShuntCompensator(j_e)) return l_shuntcompensator @@ -287,7 +292,7 @@ def get_static_var_compensator_count(self): def get_static_var_compensators(self): l_staticvarcompensator = [] - for j_e in self.j_instance.getStaticVarCompensators().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getStaticVarCompensators()): l_staticvarcompensator.append(StaticVarCompensator(j_e)) return l_staticvarcompensator @@ -299,7 +304,7 @@ def get_substation_count(self): def get_substations(self): l_substation = [] - for j_e in self.j_instance.getSubstations().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getSubstations()): l_substation.append(Substation(j_e)) return l_substation @@ -311,7 +316,7 @@ def get_switch_count(self): def get_switches(self): l_switch = [] - for j_e in self.j_instance.getSwitches().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getSwitches()): l_switch.append(Switch(j_e)) return l_switch @@ -323,7 +328,7 @@ def get_three_windings_transformer_count(self): def get_three_windings_transformers(self): l_threewindingstransformer = [] - for j_e in self.j_instance.getThreeWindingsTransformers().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getThreeWindingsTransformers()): l_threewindingstransformer.append(ThreeWindingsTransformer(j_e)) return l_threewindingstransformer @@ -335,7 +340,7 @@ def get_two_windings_transformer_count(self): def get_two_windings_transformers(self): l_twowindingstransformer = [] - for j_e in self.j_instance.getTwoWindingsTransformers().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getTwoWindingsTransformers()): l_twowindingstransformer.append(TwoWindingsTransformer(j_e)) return l_twowindingstransformer @@ -347,7 +352,7 @@ def get_voltage_level_count(self): def get_voltage_levels(self): l_voltagelevel = [] - for j_e in self.j_instance.getVoltageLevels().toList(): + for j_e in Lists.newArrayList(self.j_instance.getVoltageLevels()): l_voltagelevel.append(VoltageLevel(j_e)) return l_voltagelevel @@ -359,7 +364,7 @@ def get_vsc_converter_station_count(self): def get_vsc_converter_stations(self): l_vscconverterstation = [] - for j_e in self.j_instance.getVscConverterStations().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getVscConverterStations()): l_vscconverterstation.append(VscConverterStation(j_e)) return l_vscconverterstation @@ -487,31 +492,31 @@ def get_connected_terminal_count(self): def get_dangling_lines(self): l_danglingline = [] - for j_e in self.j_instance.getDanglingLines().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getDanglingLines()): l_danglingline.append(DanglingLine(j_e)) return l_danglingline def get_generators(self): l_generator = [] - for j_e in self.j_instance.getGenerators().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getGenerators()): l_generator.append(Generator(j_e)) return l_generator def get_lcc_converter_stations(self): l_lccconverterstation = [] - for j_e in self.j_instance.getLccConverterStations().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getLccConverterStations()): l_lccconverterstation.append(LccConverterStation(j_e)) return l_lccconverterstation def get_lines(self): l_line = [] - for j_e in self.j_instance.getLines().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getLines()): l_line.append(Line(j_e)) return l_line def get_loads(self): l_load = [] - for j_e in self.j_instance.getLoads().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getLoads()): l_load.append(Load(j_e)) return l_load @@ -523,13 +528,13 @@ def get_q(self): def get_shunt_compensators(self): l_shuntcompensator = [] - for j_e in self.j_instance.getShuntCompensators().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getShuntCompensators()): l_shuntcompensator.append(ShuntCompensator(j_e)) return l_shuntcompensator def get_static_var_compensators(self): l_staticvarcompensator = [] - for j_e in self.j_instance.getStaticVarCompensators().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getStaticVarCompensators()): l_staticvarcompensator.append(StaticVarCompensator(j_e)) return l_staticvarcompensator @@ -538,13 +543,13 @@ def get_synchronous_component(self): def get_three_windings_transformers(self): l_threewindingtransformer = [] - for j_e in self.j_instance.getThreeWindingsTransformers().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getThreeWindingsTransformers()): l_threewindingtransformer.append(ThreeWindingsTransformer(j_e)) return l_threewindingtransformer def get_two_windings_transformers(self): l_twowindingtransformer = [] - for j_e in self.j_instance.getTwoWindingsTransformers().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getTwoWindingsTransformers()): l_twowindingtransformer.append(TwoWindingsTransformer(j_e)) return l_twowindingtransformer @@ -556,7 +561,7 @@ def get_voltage_level(self): def get_vsc_converter_stations(self): l_vscconverterstation = [] - for j_e in self.j_instance.getVscConverterStations().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getVscConverterStations()): l_vscconverterstation.append(VscConverterStation(j_e)) return l_vscconverterstation @@ -578,7 +583,7 @@ def get_num(self): def get_buses(self): l_bus = [] - for j_e in self.j_instance.getBuses().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getBuses()): l_bus.append(Bus(j_e)) return l_bus @@ -897,7 +902,7 @@ def get_high_voltage_limit(self): def get_connectables(self): l_connectable = [] - for j_e in self.j_instance.getConnectables().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getConnectables()): l_connectable.append(Connectable(j_e)) return l_connectable @@ -909,7 +914,7 @@ def get_connectable_count(self): def get_generators(self): l_generator = [] - for j_e in self.j_instance.getGenerators().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getGenerators()): l_generator.append(Generator(j_e)) return l_generator @@ -918,13 +923,13 @@ def get_generator_count(self): def get_loads(self): l_load = [] - for j_e in self.j_instance.getLoads().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getLoads()): l_load.append(Load(j_e)) return l_load def get_switches(self): l_switch = [] - for j_e in self.j_instance.getSwitches().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getSwitches()): l_switch.append(Switch(j_e)) return l_switch @@ -939,7 +944,7 @@ def get_shunt_count(self): def get_shunt_compensators(self): l_shuntcompensator = [] - for j_e in self.j_instance.getShuntCompensators().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getShuntCompensators()): l_shuntcompensator.append(ShuntCompensator(j_e)) return l_shuntcompensator @@ -948,7 +953,7 @@ def get_shunt_compensator_count(self): def get_dangling_lines(self): l_danglingline = [] - for j_e in self.j_instance.getDanglingLines().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getDanglingLines()): l_danglingline.append(DanglingLine(j_e)) return l_danglingline @@ -957,7 +962,7 @@ def get_dangling_line_count(self): def get_static_var_compensators(self): l_staticvarcompensator = [] - for j_e in self.j_instance.getStaticVarCompensators().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getStaticVarCompensators()): l_staticvarcompensator.append(StaticVarCompensator(j_e)) return l_staticvarcompensator @@ -966,7 +971,7 @@ def get_static_var_compensator_count(self): def get_vsc_converter_stations(self): l_vscconverterstation = [] - for j_e in self.j_instance.getVscConverterStations().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getVscConverterStations()): l_vscconverterstation.append(VscConverterStation(j_e)) return l_vscconverterstation @@ -975,7 +980,7 @@ def get_vsc_converter_station_count(self): def get_lcc_converter_stations(self): l_lccconverterstation = [] - for j_e in self.j_instance.getLccConverterStations().toArray(): + for j_e in Lists.newArrayList(self.j_instance.getLccConverterStations()): l_lccconverterstation.append(LccConverterStation(j_e)) return l_lccconverterstation diff --git a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java index e7ca0ebd..51d46164 100644 --- a/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java +++ b/py-powsybl/src/main/java/com/powsybl/powsybl/PythonCodeGenerator.java @@ -109,7 +109,7 @@ public static void main(String... args) { String eleClazzName = getReturnElementClassName(methodName); String eleListVar = "l_" + eleClazzName.toLowerCase(); codes.add(A2 + eleListVar + " = []"); - codes.add(A2 + pythonForStatement(methodName, clazz)); + codes.add(A2 + foreachInIterable(methodName)); codes.add(A3 + eleListVar + ".append(" + eleClazzName + "(j_e))"); codes.add(A2_RETURN + eleListVar); @@ -145,14 +145,8 @@ public static void main(String... args) { codes.stream().forEach(l -> System.out.println(l)); } - // TODO init a real network in jvm and check instance type - static String pythonForStatement(String methodName, Class c) { - String collection = "Array"; - // TODO Bus.getFoos() - if (c.getSimpleName().equals("Network") && MUTABLE_COLLECTIONS_METHOD.contains(methodName)) { - collection = "List"; - } - return "for j_e in self.j_instance." + methodName + "().to" + collection + "():"; + static String foreachInIterable(String methodName) { + return "for j_e in Lists.newArrayList(self.j_instance." + methodName + "()):"; } static String argsDef(Method m) { From 81332dc2604c54fc979c7a6f544c54d88de6f075 Mon Sep 17 00:00:00 2001 From: yichen88 Date: Mon, 10 Dec 2018 11:37:47 +0100 Subject: [PATCH 14/14] Autocloseable py-powsybl --- py-powsybl/README.md | 7 +------ py-powsybl/pypowsybl/__init__.py | 10 +++++++++- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/py-powsybl/README.md b/py-powsybl/README.md index b46048a1..790d4cbb 100644 --- a/py-powsybl/README.md +++ b/py-powsybl/README.md @@ -45,8 +45,7 @@ def dump_lines_flow(network): if __name__ == '__main__': port = 3338 - launch("config2", port) - if connect(port): + with launch(config_name=None, nb_port=port): n1 = load_network("/path/to/case-file/example.xiidm") dump_lines_flow(n1) @@ -61,10 +60,6 @@ if __name__ == '__main__': n1.save("/path/to/output/example.xiidm") # or save(n1, "/path/to/output/example.xiidm") - # don't forget to shundown jvm - shutdown_pypowsybl() - else: - print("can not connect to jvm") ``` diff --git a/py-powsybl/pypowsybl/__init__.py b/py-powsybl/pypowsybl/__init__.py index d992d479..748e6eaa 100644 --- a/py-powsybl/pypowsybl/__init__.py +++ b/py-powsybl/pypowsybl/__init__.py @@ -4,6 +4,7 @@ # file, You can obtain one at http://mozilla.org/MPL/2.0/. import subprocess import time +from contextlib import contextmanager from enum import Enum from threading import Thread @@ -38,9 +39,13 @@ def launch(nb_port): launch(None, nb_port) +@contextmanager def launch(config_name, nb_port): t = Thread(target=launch_task, args=(config_name, nb_port)) t.start() + connect(nb_port) + yield + shutdown_pypowsybl() def connect(nb_port): @@ -130,7 +135,10 @@ def save(network, str_path): def shutdown_pypowsybl(): - gateway.shutdown() + try: + gateway.shutdown() + except ConnectionRefusedError: + pass class Identifiable: