From b0bd5e3d01c39adf74c435d98630be80a166cfe2 Mon Sep 17 00:00:00 2001 From: jeandemanged Date: Sun, 10 Nov 2024 19:18:23 +0100 Subject: [PATCH] Init yagat application (#1) Signed-off-by: Damien Jeandemange --- .github/workflows/ci.yml | 69 +++++ .gitignore | 10 + README.md | 96 ++++++- requirements.in | Bin 0 -> 778 bytes requirements.txt | 62 +++++ sonar-project.properties | 6 + tests/__init__.py | 7 + tests/test_app_context.py | 99 +++++++ tests/test_network_structure.py | 167 +++++++++++ yagat.spec | 63 +++++ yagat/__init__.py | 14 + yagat/app.py | 49 ++++ yagat/app_context.py | 134 +++++++++ yagat/frames/__init__.py | 14 + yagat/frames/impl/__init__.py | 7 + yagat/frames/impl/diagram_view.py | 45 +++ yagat/frames/impl/diagram_view_bus.py | 137 +++++++++ yagat/frames/impl/load_flow_parameters.py | 240 ++++++++++++++++ yagat/frames/impl/main_application.py | 80 ++++++ yagat/frames/impl/splash_screen.py | 31 +++ yagat/frames/impl/status_bar.py | 33 +++ yagat/frames/impl/tree_and_diagram.py | 36 +++ yagat/frames/impl/tree_view.py | 169 ++++++++++++ yagat/frames/impl/vertical_scrolled_frame.py | 105 +++++++ yagat/images/logo.png | Bin 0 -> 75950 bytes yagat/images/splash.png | Bin 0 -> 170200 bytes yagat/menus/__init__.py | 8 + yagat/menus/impl/__init__.py | 7 + yagat/menus/impl/bar.py | 22 ++ yagat/menus/impl/file.py | 83 ++++++ yagat/menus/impl/help.py | 26 ++ yagat/menus/impl/run.py | 33 +++ yagat/menus/impl/view.py | 28 ++ yagat/networkstructure/__init__.py | 13 + yagat/networkstructure/impl/__init__.py | 7 + yagat/networkstructure/impl/bus_views.py | 13 + yagat/networkstructure/impl/connection.py | 98 +++++++ yagat/networkstructure/impl/equipment_type.py | 37 +++ .../impl/network_structure.py | 261 ++++++++++++++++++ yagat/networkstructure/impl/substation.py | 44 +++ yagat/networkstructure/impl/voltage_level.py | 68 +++++ yagat/utils/__init__.py | 9 + yagat/utils/impl/__init__.py | 7 + yagat/utils/impl/formatting_utils.py | 21 ++ yagat/utils/impl/screen_utils.py | 30 ++ yagat/widgets/__init__.py | 9 + yagat/widgets/impl/__init__.py | 7 + yagat/widgets/impl/label_value.py | 41 +++ yagat/widgets/impl/substation.py | 242 ++++++++++++++++ 49 files changed, 2786 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/ci.yml create mode 100644 .gitignore create mode 100644 requirements.in create mode 100644 requirements.txt create mode 100644 sonar-project.properties create mode 100644 tests/__init__.py create mode 100644 tests/test_app_context.py create mode 100644 tests/test_network_structure.py create mode 100644 yagat.spec create mode 100644 yagat/__init__.py create mode 100644 yagat/app.py create mode 100644 yagat/app_context.py create mode 100644 yagat/frames/__init__.py create mode 100644 yagat/frames/impl/__init__.py create mode 100644 yagat/frames/impl/diagram_view.py create mode 100644 yagat/frames/impl/diagram_view_bus.py create mode 100644 yagat/frames/impl/load_flow_parameters.py create mode 100644 yagat/frames/impl/main_application.py create mode 100644 yagat/frames/impl/splash_screen.py create mode 100644 yagat/frames/impl/status_bar.py create mode 100644 yagat/frames/impl/tree_and_diagram.py create mode 100644 yagat/frames/impl/tree_view.py create mode 100644 yagat/frames/impl/vertical_scrolled_frame.py create mode 100644 yagat/images/logo.png create mode 100644 yagat/images/splash.png create mode 100644 yagat/menus/__init__.py create mode 100644 yagat/menus/impl/__init__.py create mode 100644 yagat/menus/impl/bar.py create mode 100644 yagat/menus/impl/file.py create mode 100644 yagat/menus/impl/help.py create mode 100644 yagat/menus/impl/run.py create mode 100644 yagat/menus/impl/view.py create mode 100644 yagat/networkstructure/__init__.py create mode 100644 yagat/networkstructure/impl/__init__.py create mode 100644 yagat/networkstructure/impl/bus_views.py create mode 100644 yagat/networkstructure/impl/connection.py create mode 100644 yagat/networkstructure/impl/equipment_type.py create mode 100644 yagat/networkstructure/impl/network_structure.py create mode 100644 yagat/networkstructure/impl/substation.py create mode 100644 yagat/networkstructure/impl/voltage_level.py create mode 100644 yagat/utils/__init__.py create mode 100644 yagat/utils/impl/__init__.py create mode 100644 yagat/utils/impl/formatting_utils.py create mode 100644 yagat/utils/impl/screen_utils.py create mode 100644 yagat/widgets/__init__.py create mode 100644 yagat/widgets/impl/__init__.py create mode 100644 yagat/widgets/impl/label_value.py create mode 100644 yagat/widgets/impl/substation.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..c9e3bbf --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,69 @@ +name: CI + +on: + pull_request: + workflow_dispatch: + inputs: + upload_artifacts: + description: 'Upload build artifacts' + required: true + default: false + type: boolean + +permissions: { } + +jobs: + build: + name: Build on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + + env: + DISPLAY: :99 + + steps: + - name: Checkout sources + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.12' + cache: 'pip' + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements.txt + + - name: Xvfb (Linux only) + if: matrix.os == 'ubuntu-latest' + run: | + sudo apt-get update -y + sudo apt-get install -y xvfb + Xvfb -ac $DISPLAY -screen 0 1280x1024x24 > /dev/null 2>&1 & + + - name: Test with pytest + run: | + coverage run --branch -m pytest tests + coverage xml + coverage report + + - name: SonarCloud Scan (Linux only) + if: matrix.os == 'ubuntu-latest' + uses: SonarSource/sonarcloud-github-action@v3.1.0 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # Needed to get PR information, if any + SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} + + - name: Build application with PyInstaller + run: pyinstaller -y yagat.spec + + - name: Upload application Artifact + if: ${{ github.event_name == 'workflow_dispatch' && inputs.upload_artifacts }} + uses: actions/upload-artifact@v4 + with: + name: yagat-${{ matrix.os }} + path: dist/yagat* diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..73ecf0f --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +*.iml +*.zip +.idea +venv +/build/ +/dist/ +__pycache__/ +/.coverage +/coverage.xml +/junit/ diff --git a/README.md b/README.md index 3ae414a..0745db4 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,97 @@ # YAGAT -Yet Another Grid Analysis Tool +**Y**et **A**nother **G**rid **A**nalysis **T**ool + +## Overview + +YAGAT provides a graphical user interface built on top of the [PowSyBl](https://www.powsybl.org) open source grid analysis libraries. + +With YAGAT no computer science skill is required: just download the application and run it. + +Today with YAGAT you can: +- Load grid models from the various formats supported by [PowSyBl](https://www.powsybl.org): + - CIM/CGMES + - UCTE-DEF + - IEEE-CDF + - MATPOWER + - Siemens PSS®E +- Display and navigate the grid model with electrical buses represented in tabular form +- Run a Load Flow, visualize solved bus voltages and branch flows + +## Installation + +### Binary releases + +Binary releases are provided for Windows, Linux and macOS on the [releases page](https://github.com/jeandemanged/yagat/releases). +No additional software is required for installation. +Download and extract the zip archive for your platform, then run YAGAT. + +### Building from source + +With Python 3.12 and e.g. using a Virtual Environment and `pip`. + +```bash +# clone the git repository +git clone https://github.com/jeandemanged/yagat.git +cd yagat +``` + +```bash +# install requirements +python -m venv venv +. venv/bin/activate +pip install -r requirements.txt +``` + +```bash +# build the application +pyinstaller -y yagat.spec +``` + +YAGAT is then available for your platform in the `dist` directory. + +## Quick Start + +- **Open a sample network**: Go to `File` | `Open Sample network` | `IEEE 9 Bus` to load a sample grid model. +- **Navigate the grid**: Use the tree view on the left to browse through the network model and its elements. +- **Run the Load Flow**: Select `Run` | `Load Flow` to execute the analysis. + - Once completed, view the solved bus voltages and branch flows for insights into the grid's state. + +## Roadmap + +YAGAT today lacks many features, but you may already find it useful. What is planned for the future is: + +### Short-Term to Mid-Term Plans: +- **General**: A log view +- **Grid Model Navigation**: Tabular views per equipment type +- **Grid Model Updates**: Adjust grid configurations, such as opening/closing switches, changing generator set points, etc. +- **Load Flow**: + - Add ability to save/load the Load Flow parameters + - View Load Flow reports in order to troubleshoot e.g. non-convergence + +### Future Plans: +- **Security Analysis**: + - Configure a list of contingencies to simulate + - Run contingency analysis + - View contingency violations + +## Under the Hood + +YAGAT is: +- **Written in Python**: a high-level, general-purpose programming language. +- **Using [PyPowSyBl](https://pypowsybl.readthedocs.io/en/latest/index.html)**: Provides the core grid analysis functionalities. +- **Using [Tkinter](https://wiki.python.org/moin/TkInter)**: Supplies the graphical user interface. +- **Using [Tksheet](https://github.com/ragardner/tksheet)**: An amazing tkinter table widget. +- **Using [PyInstaller](https://pyinstaller.org/en/stable/)**: Packages the application. + +## Data Confidentiality + +We take data confidentiality seriously. +All data processed by the application remains on the user's local machine and is not transmitted to any external servers. +This ensures complete data privacy for users working with sensitive grid models. + +## Contributing and Support + +Should you encounter any issues with YAGAT, please let us know. +We welcome contributions, ideas, and feedback. Please open an [issue](https://github.com/jeandemanged/yagat/issues) +or [pull request](https://github.com/jeandemanged/yagat/pulls) to get involved. diff --git a/requirements.in b/requirements.in new file mode 100644 index 0000000000000000000000000000000000000000..8e2d5e169a61899ea25a81f855d6e24c493a3f3b GIT binary patch literal 778 zcmZvaO-sXI5QOI}_#XnjDA?AD2N6731f_*SJ?Jq_Keb=9X-oa_>NA^01xrZY-F+NWLAJ($3XKE&(Bzy!R_pvxU-G8(D2Vq8~+20DNjng6F5^M*-tmE@I3n(9P6=V8Y@&oBU_Jw z>3Yv-MgQ}3)FQfr#a+zFv)cXWKaUOc;C83|$Sag9X0R5eHpA$)=;IZX4cS?2!JIu1 zQZl@!1z%5}22;74Vly*tf9I~@t=LvwZ4_v67PHlvuH@}<)6|Qq+*_Sek1Er9Cv#XP z=-|I(#r~56R`q~Y;P`8OmN4#^YEQ>g-SITwy5VgEW3G2@$6yV>Evu}~`iNf*-M2q^ Sp5J+C?A84g2*sYwZ2ueU^nW%0 literal 0 HcmV?d00001 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..2b9f19f --- /dev/null +++ b/requirements.txt @@ -0,0 +1,62 @@ +# +# This file is autogenerated by pip-compile with Python 3.12 +# by the following command: +# +# pip-compile requirements.in +# +altgraph==0.17.4 + # via pyinstaller +colorama==0.4.6 + # via pytest +coverage[toml]==7.6.4 + # via pytest-cov +iniconfig==2.0.0 + # via pytest +networkx==3.4.2 + # via pypowsybl +numpy==2.1.3 + # via pandas +packaging==24.2 + # via + # pyinstaller + # pyinstaller-hooks-contrib + # pytest +pandas==2.2.3 + # via pypowsybl +pefile==2023.2.7 + # via pyinstaller +pillow==11.0.0 + # via -r requirements.in +pluggy==1.5.0 + # via pytest +prettytable==3.12.0 + # via pypowsybl +pyinstaller==6.11.0 + # via -r requirements.in +pyinstaller-hooks-contrib==2024.9 + # via pyinstaller +pypowsybl==1.8.1 + # via -r requirements.in +pytest==8.3.3 + # via + # -r requirements.in + # pytest-cov +pytest-cov==6.0.0 + # via -r requirements.in +python-dateutil==2.9.0.post0 + # via pandas +pytz==2024.2 + # via pandas +pywin32-ctypes==0.2.3 + # via pyinstaller +six==1.16.0 + # via python-dateutil +tksheet==7.2.21 + # via -r requirements.in +tzdata==2024.2 + # via pandas +wcwidth==0.2.13 + # via prettytable + +# The following packages are considered to be unsafe in a requirements file: +# setuptools diff --git a/sonar-project.properties b/sonar-project.properties new file mode 100644 index 0000000..9ccfe7b --- /dev/null +++ b/sonar-project.properties @@ -0,0 +1,6 @@ +sonar.projectKey=jeandemanged_yagat +sonar.organization=jeandemanged + +sonar.sources=yagat +sonar.tests=tests +sonar.python.coverage.reportPaths=coverage.xml diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..65327b4 --- /dev/null +++ b/tests/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# diff --git a/tests/test_app_context.py b/tests/test_app_context.py new file mode 100644 index 0000000..92756e1 --- /dev/null +++ b/tests/test_app_context.py @@ -0,0 +1,99 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk + +import pypowsybl.network as pn +import pytest + +from yagat.app_context import AppContext + + +class TestListener: + + __test__ = False + + def __init__(self, context: AppContext): + self._status_text_from_listener = None + self._network_from_listener = None + self._selection_from_listener = None + self._selected_tab_from_listener = None + context.add_status_text_listener(lambda value: self.status_text_listener(value)) + context.add_network_changed_listener(lambda value: self.network_listener(value)) + context.add_selection_changed_listener(lambda value: self.selection_listener(value)) + context.add_tab_changed_listener(lambda value: self.selected_tab_listener(value)) + + def status_text_listener(self, value): + self._status_text_from_listener = value + + def network_listener(self, value): + self._network_from_listener = value + + def selection_listener(self, value): + self._selection_from_listener = value + + def selected_tab_listener(self, value): + self._selected_tab_from_listener = value + + @property + def status_text_from_listener(self): + return self._status_text_from_listener + + @property + def network_from_listener(self) -> pn.Network: + return self._network_from_listener + + @property + def selection_from_listener(self): + return self._selection_from_listener + + @property + def selected_tab_from_listener(self): + return self._selected_tab_from_listener + + +class TestAppContext: + + @pytest.fixture + def context(self): + context = AppContext(tk.Tk()) + yield context + + def test_initial_state(self, context): + assert context.tk_root is not None + assert context.network is None + assert context.network_structure is None + assert context.selection[0] is None + assert context.selection[1] is None + assert context.selection[2] is None + assert context.status_text == 'Welcome' + + def test_status_text(self, context): + test = TestListener(context) + context.status_text = 'test status text' + assert test.status_text_from_listener == 'test status text' + + def test_network(self, context): + test = TestListener(context) + context.network = pn.create_ieee9() + assert test.network_from_listener.name == 'ieee9cdf' + context.network = None + assert test.network_from_listener is None + + def test_selection(self, context): + test = TestListener(context) + context.selection = 'test selection' + assert test.selection_from_listener == 'test selection' + context.selection = None + assert test.selection_from_listener is None + + def test_selected_tab(self, context): + test = TestListener(context) + context.selected_tab = 'test selected tab' + assert test.selected_tab_from_listener == 'test selected tab' + context.selected_tab = None + assert test.selected_tab_from_listener is None diff --git a/tests/test_network_structure.py b/tests/test_network_structure.py new file mode 100644 index 0000000..89909c5 --- /dev/null +++ b/tests/test_network_structure.py @@ -0,0 +1,167 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import pypowsybl.network as pn +import pypowsybl.loadflow as lf +import pytest +import numpy as np + +import yagat.networkstructure as ns + + +class TestNetworkStructureIeee9: + + @pytest.fixture + def setup(self): + network = pn.create_ieee9() + structure = ns.NetworkStructure(network) + yield network, structure + + def test_structure(self, setup): + _, structure = setup + assert len(structure.substations) == 6 + assert len(structure.voltage_levels) == 6 + assert structure.get_substation('not exists s') is None + assert structure.get_voltage_level('not exists vl') is None + s1 = structure.get_substation('S1') + assert s1 is not None + assert isinstance(s1, ns.Substation) + vl1 = structure.get_voltage_level('VL1') + assert vl1 is not None + assert isinstance(vl1, ns.VoltageLevel) + s2 = structure.get_substation_or_voltage_level('S2') + assert s2 is not None + assert isinstance(s2, ns.Substation) + vl2 = structure.get_substation_or_voltage_level('VL2') + assert vl2 is not None + assert isinstance(vl2, ns.VoltageLevel) + with pytest.raises(RuntimeError): + structure.get_substation_or_voltage_level('not_exists') + + def test_substation(self, setup): + _, structure = setup + s1 = structure.get_substation('S1') + assert s1.network_structure == structure + assert s1.substation_id == 'S1' + assert s1.name == 'S1' + assert len(s1.voltage_levels) == 1 + vl1 = s1.get_voltage_level('VL1') + assert vl1 is not None + assert isinstance(vl1, ns.VoltageLevel) + assert s1.get_voltage_level('not exists vl') is None + + def test_voltage_level(self, setup): + _, structure = setup + s1 = structure.get_substation('S1') + vl1 = structure.get_voltage_level('VL1') + assert vl1.network_structure == structure + assert vl1.substation == s1 + assert vl1.voltage_level_id == 'VL1' + assert vl1.name == 'VL1' + assert len(vl1.connections) == 5 + l540 = vl1.get_connection('L5-4-0', 2) + assert l540 is not None + assert isinstance(l540, ns.Connection) + assert vl1.get_connection('not exists c') is None + + def test_voltage_level_buses(self, setup): + _, structure = setup + vl1 = structure.get_voltage_level('VL1') + vl1_buses = vl1.get_buses(ns.BusView.BUS_BRANCH) + vl2 = structure.get_voltage_level('VL2') + vl2_buses = vl2.get_buses(ns.BusView.BUS_BRANCH) + assert len(vl1_buses) == 2 + assert len(vl2_buses) == 2 + assert 'VL1_0' in vl1_buses.index + assert 'VL1_1' in vl1_buses.index + assert 'VL2_0' in vl2_buses.index + assert 'VL2_1' in vl2_buses.index + assert 'VL2_0' not in vl1_buses.index + assert 'VL1_0' not in vl2_buses.index + vl1_0_connections = vl1.get_bus_connections(ns.BusView.BUS_BRANCH, 'VL1_0') + assert len(vl1_0_connections) == 2 + + def test_connection(self, setup): + _, structure = setup + s1 = structure.get_substation('S1') + vl1 = structure.get_voltage_level('VL1') + + l540 = vl1.get_connection('L5-4-0', 2) + assert l540.substation == s1 + assert l540.voltage_level == vl1 + assert l540.network_structure == structure + assert l540.equipment_id == 'L5-4-0' + assert l540.name == 'L5-4-0' + assert l540.equipment_type == 'LINE' + assert l540.side == 2 + + t410 = vl1.get_connection('T4-1-0', 1) + assert t410.equipment_id == 'T4-1-0' + assert t410.name == 'T4-1-0' + assert t410.equipment_type == ns.EquipmentType.TWO_WINDINGS_TRANSFORMER + assert t410.side == 1 + + b1g = vl1.get_connection('B1-G') + assert b1g.equipment_id == 'B1-G' + assert b1g.name == 'B1-G' + assert b1g.equipment_type == ns.EquipmentType.GENERATOR + assert b1g.side is None + + def test_connection_data(self, setup): + network, structure = setup + connection_data = structure.get_connection_data('L5-4-0', 2) + assert np.isnan(connection_data.p1) + lf.run_ac(network) + structure.refresh() + connection_data = structure.get_connection_data('L5-4-0', 2) + assert connection_data.p1 == pytest.approx(-40.7, 0.1) + + def test_connection_from_structure(self, setup): + _, structure = setup + t410_1 = structure.get_connection('T4-1-0', 1) + t410_2 = structure.get_connection('T4-1-0', 2) + assert t410_1.voltage_level.voltage_level_id == 'VL1' + assert t410_2.voltage_level.voltage_level_id == 'VL1' + + +class TestNetworkStructureMicroGridBe: + + @pytest.fixture + def setup(self): + network = pn.create_micro_grid_be_network() + structure = ns.NetworkStructure(network) + yield network, structure + + def test_structure(self, setup): + _, structure = setup + assert len(structure.substations) == 2 + assert len(structure.voltage_levels) == 6 + + anvers = structure.get_substation('87f7002b-056f-4a6a-a872-1744eea757e3') + assert anvers.name == 'Anvers' + assert len(anvers.voltage_levels) == 1 + + brussels = structure.get_substation('37e14a0f-5e34-4647-a062-8bfd9305fa9d') + assert brussels.name == 'PP_Brussels' + assert len(brussels.voltage_levels) == 5 + + brussels_380 = structure.get_voltage_level('469df5f7-058f-4451-a998-57a48e8a56fe') + assert brussels_380.name == '380.0' + assert len(brussels_380.connections) == 6 + tr3 = brussels_380.get_connection('84ed55f4-61f5-4d9d-8755-bba7b877a246', 1) + assert tr3.name == 'BE-TR3_1' + assert tr3.equipment_type == ns.EquipmentType.THREE_WINDINGS_TRANSFORMER + dangling_line3 = brussels_380.get_connection('78736387-5f60-4832-b3fe-d50daf81b0a6') + assert dangling_line3.name == 'BE-Line_3' + assert dangling_line3.equipment_type == ns.EquipmentType.DANGLING_LINE + + brussels_110 = structure.get_voltage_level('8bbd7e74-ae20-4dce-8780-c20f8e18c2e0') + assert brussels_110.name == '110.0' + assert len(brussels_110.connections) == 5 + s1 = brussels_110.get_connection('d771118f-36e9-4115-a128-cc3d9ce3e3da') + assert s1.name == 'BE_S1' + assert s1.equipment_type == ns.EquipmentType.SHUNT_COMPENSATOR diff --git a/yagat.spec b/yagat.spec new file mode 100644 index 0000000..6c541ec --- /dev/null +++ b/yagat.spec @@ -0,0 +1,63 @@ +# -*- mode: python ; coding: utf-8 -*- +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import platform +import sys + +sys.path.append('./') +from yagat import __version__ + +from PyInstaller.utils.hooks import collect_dynamic_libs + +datas = [('yagat/images', 'yagat/images')] +binaries = [] +hiddenimports = ['PIL._tkinter_finder'] +binaries += collect_dynamic_libs('pypowsybl') + +a = Analysis( + ['yagat/app.py'], + pathex=['yagat'], + binaries=binaries, + datas=datas, + hiddenimports=hiddenimports, + hookspath=[], + hooksconfig={}, + runtime_hooks=[], + excludes=[], + noarchive=False, + optimize=0, +) +pyz = PYZ(a.pure) + +exe = EXE( + pyz, + a.scripts, + [], + exclude_binaries=True, + name='YAGAT', + icon='yagat/images/logo.png', + debug=False, + bootloader_ignore_signals=False, + strip=False, + upx=True, + console=False, + disable_windowed_traceback=False, + argv_emulation=False, + target_arch=None, + codesign_identity=None, + entitlements_file=None, +) +coll = COLLECT( + exe, + a.binaries, + a.datas, + strip=False, + upx=True, + upx_exclude=[], + name=f'yagat_{__version__}_{platform.system()}', +) diff --git a/yagat/__init__.py b/yagat/__init__.py new file mode 100644 index 0000000..82fd9a7 --- /dev/null +++ b/yagat/__init__.py @@ -0,0 +1,14 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import os + +__version__ = '0.1.0-dev' + + +def get_app_path() -> os.path: + return os.path.dirname(os.path.abspath(__file__)) diff --git a/yagat/app.py b/yagat/app.py new file mode 100644 index 0000000..da7c403 --- /dev/null +++ b/yagat/app.py @@ -0,0 +1,49 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import logging +import os +import tkinter as tk + +import pypowsybl as pp + +from yagat import get_app_path +from yagat.frames import SplashScreen, MainApplication + +pp.print_version() + +logging.getLogger('powsybl').setLevel(logging.INFO) +logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=logging.INFO) + +if __name__ == "__main__": + + splash_root = tk.Tk() + splash_root.iconphoto(True, tk.PhotoImage(file=os.path.join(get_app_path(), 'images/logo.png'))) + + + def main_window(): + splash_root.destroy() + root = tk.Tk() + + # Remove ttk Combobox Mousewheel Binding, see https://stackoverflow.com/questions/44268882/remove-ttk-combobox-mousewheel-binding + root.unbind_class("TCombobox", "") # Windows & OSX + root.unbind_class("TCombobox", "") # Linux and other *nix systems + root.unbind_class("TCombobox", "") # Linux and other *nix systems + + MainApplication(root) + root.mainloop() + + + if os.name == 'nt': + # Fixing the blur UI on Windows + from ctypes import windll + + windll.shcore.SetProcessDpiAwareness(2) + + splash = SplashScreen(splash_root) + splash.after(1500, main_window) + splash_root.mainloop() diff --git a/yagat/app_context.py b/yagat/app_context.py new file mode 100644 index 0000000..4dc5df4 --- /dev/null +++ b/yagat/app_context.py @@ -0,0 +1,134 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import logging +import tkinter as tk +from typing import Callable, Optional + +import pypowsybl.network as pn +import pypowsybl.loadflow as lf + +import yagat.networkstructure as ns + + +class AppContext: + def __init__(self, root: tk.Tk): + self._root = root + self._network: Optional[pn.Network] = None + self._lf_parameters: lf.Parameters = lf.Parameters() + self._network_structure: Optional[ns.NetworkStructure] = None + self._selection: tuple[Optional[str], Optional[str], Optional[ns.Connection]] = (None, None, None) + self._status_text: str = 'Welcome' + self._selected_tab: str = '' + self._selected_view: str = '' + self.status_text_changed_listeners = [] + self.network_changed_listeners = [] + self.selection_changed_listeners = [] + self.tab_changed_listeners = [] + self.view_changed_listeners = [] + + @property + def tk_root(self) -> tk.Tk: + return self._root + + @property + def status_text(self) -> str: + return self._status_text + + @status_text.setter + def status_text(self, value: str) -> None: + logging.info(value) + self._status_text = value + self.notify_status_text_changed() + + @property + def selected_tab(self) -> str: + return self._selected_tab + + @selected_tab.setter + def selected_tab(self, value: str) -> None: + self._selected_tab = value + self.notify_tab_changed() + + @property + def selected_view(self) -> str: + return self._selected_view + + @selected_view.setter + def selected_view(self, value: str) -> None: + self._selected_view = value + self.notify_view_changed() + + @property + def network(self) -> Optional[pn.Network]: + return self._network + + @property + def lf_parameters(self) -> lf.Parameters: + return self._lf_parameters + + @property + def network_structure(self) -> Optional[ns.NetworkStructure]: + return self._network_structure + + @network.setter + def network(self, new_network: Optional[pn.Network]) -> None: + self._network = new_network + if new_network: + self._network_structure = ns.NetworkStructure(new_network) + else: + self._network_structure = None + self.selection = (None, None, None) + self.notify_network_changed() + + @property + def selection(self) -> tuple[Optional[str], Optional[str], Optional[ns.Connection]]: + return self._selection + + @selection.setter + def selection(self, value: tuple[Optional[str], Optional[str], Optional[ns.Connection]]) -> None: + logging.info(f'selection setter called {value}') + self._selection = value + self.notify_selection_changed() + + def reset_selected_connection(self): + self._selection = (self._selection[0], self._selection[1], None) + + def add_status_text_listener(self, listener: Callable[[str], None]) -> None: + self.status_text_changed_listeners.append(listener) + + def notify_status_text_changed(self) -> None: + for listener in self.status_text_changed_listeners: + listener(self.status_text) + + def add_network_changed_listener(self, listener: Callable[[Optional[pn.Network]], None]) -> None: + self.network_changed_listeners.append(listener) + + def notify_network_changed(self) -> None: + for listener in self.network_changed_listeners: + listener(self.network) + + def add_selection_changed_listener(self, listener: Callable[[tuple[Optional[str], Optional[str], Optional[ns.Connection]]], None]) -> None: + self.selection_changed_listeners.append(listener) + + def notify_selection_changed(self) -> None: + for listener in self.selection_changed_listeners: + listener(self.selection) + + def add_tab_changed_listener(self, listener: Callable[[str], None]) -> None: + self.tab_changed_listeners.append(listener) + + def notify_tab_changed(self) -> None: + for listener in self.tab_changed_listeners: + listener(self.selected_tab) + + def add_view_changed_listener(self, listener: Callable[[str], None]) -> None: + self.view_changed_listeners.append(listener) + + def notify_view_changed(self) -> None: + for listener in self.view_changed_listeners: + listener(self.selected_view) diff --git a/yagat/frames/__init__.py b/yagat/frames/__init__.py new file mode 100644 index 0000000..c1623e5 --- /dev/null +++ b/yagat/frames/__init__.py @@ -0,0 +1,14 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from .impl.diagram_view import DiagramView +from .impl.load_flow_parameters import LoadFlowParametersView +from .impl.main_application import MainApplication +from .impl.splash_screen import SplashScreen +from .impl.status_bar import StatusBar +from .impl.tree_and_diagram import TreeAndDiagram +from .impl.tree_view import TreeView diff --git a/yagat/frames/impl/__init__.py b/yagat/frames/impl/__init__.py new file mode 100644 index 0000000..65327b4 --- /dev/null +++ b/yagat/frames/impl/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# diff --git a/yagat/frames/impl/diagram_view.py b/yagat/frames/impl/diagram_view.py new file mode 100644 index 0000000..6384ece --- /dev/null +++ b/yagat/frames/impl/diagram_view.py @@ -0,0 +1,45 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk +from tkinter import ttk + +import pypowsybl.network as pn + +from yagat.app_context import AppContext +from yagat.frames.impl.diagram_view_bus import DiagramViewBus +from yagat.networkstructure import BusView + + +class DiagramView(tk.Frame): + def __init__(self, parent, context: AppContext, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + self.context = context + self.tab_control = ttk.Notebook(self) + self.tab_control.bind("<>", lambda _: self.on_tab_changed()) + + # Bus-Breaker view tab + self.tab_bus_breaker = DiagramViewBus(self.tab_control, context, 'Bus-Breaker View', BusView.BUS_BREAKER) + self.tab_control.add(self.tab_bus_breaker, text=self.tab_bus_breaker.tab_name) + self.tab_control.pack(expand=True, fill=tk.BOTH) + + # Bus-Branch view tab + self.tab_bus_branch = DiagramViewBus(self.tab_control, context, 'Bus-Branch View', BusView.BUS_BRANCH) + self.tab_control.add(self.tab_bus_branch, text=self.tab_bus_branch.tab_name) + self.tab_control.pack(expand=True, fill=tk.BOTH) + + def on_tab_changed(self): + self.context.selected_tab = self.tab_control.tab(self.tab_control.select(), "text") + + +if __name__ == "__main__": + root = tk.Tk() + ctx = AppContext(root) + DiagramView(root, ctx).pack(fill="both", expand=True) + ctx.network = pn.create_ieee9() + ctx.selection = 'S1' + root.mainloop() diff --git a/yagat/frames/impl/diagram_view_bus.py b/yagat/frames/impl/diagram_view_bus.py new file mode 100644 index 0000000..f87b3ff --- /dev/null +++ b/yagat/frames/impl/diagram_view_bus.py @@ -0,0 +1,137 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import logging +import os +import tkinter as tk +from typing import List, Optional + +import pypowsybl.network as pn + +import yagat.widgets as pw +from yagat.app_context import AppContext +from yagat.frames.impl.vertical_scrolled_frame import VerticalScrolledFrame +from yagat.networkstructure import Substation, VoltageLevel, BusView, Connection + + +class DiagramViewBus(VerticalScrolledFrame): + def __init__(self, parent, context: AppContext, tab_name: str, bus_view: 'BusView', *args, **kwargs): + VerticalScrolledFrame.__init__(self, parent, *args, **kwargs) + self.context = context + self._tab_name = tab_name + self.bus_view = bus_view + self.widgets = [] + self.context.add_selection_changed_listener(self.on_selection_changed) + self.context.add_tab_changed_listener(lambda _: self.on_selection_changed(self.context.selection)) + + def navigate(connection: Connection): + logging.info(f'Navigating to {connection.equipment_id} side {connection.side}') + selection_type, _, _ = self.context.selection + if selection_type == 'substation' and connection.substation is not None: + new_selection_type = 'substation' + new_selection_id = connection.substation.substation_id + else: + new_selection_type = 'voltage_level' + new_selection_id = connection.voltage_level.voltage_level_id + self.context.selection = (new_selection_type, new_selection_id, connection) + + self.navigate_command = navigate + + @property + def tab_name(self) -> str: + return self._tab_name + + def on_selection_changed(self, selection: tuple[Optional[str], Optional[str], Optional[Connection]]): + _, selection_id, selection_connection = selection + selected_connection_y = 0 + if self.context.selected_tab != self.tab_name: + return + logging.info('Start drawing bus view') + for w in self.widgets: + w.destroy() + self.widgets = [] + if not selection_id: + return + if self.context.selected_tab != self.tab_name: + return + network_structure = self.context.network_structure + what = network_structure.get_substation_or_voltage_level(selection_id) + substation: Substation + voltage_levels: List[VoltageLevel] + if isinstance(what, Substation): + substation = what + voltage_levels = substation.voltage_levels + elif isinstance(what, VoltageLevel): + voltage_levels = [what] + substation = what.substation + else: + raise RuntimeError(f'Selection {selection} not found') + if substation: + s = pw.Substation(self.interior, substation) + self.widgets.append(s) + s.pack(anchor=tk.NW, padx=(0, 0)) + pady_vl = 0 + for voltage_level in voltage_levels: + vl = pw.VoltageLevel(self.interior, voltage_level) + self.widgets.append(vl) + vl.pack(anchor=tk.NW, padx=(20, 0), pady=(pady_vl, 0)) + pady_vl = 20 + + buses = voltage_level.get_buses(self.bus_view) + pady_bus = 0 + for bus_idx, bus_s in buses.iterrows(): + bus_id = str(bus_idx) + b = pw.Bus(self.interior, bus_id, bus_s) + self.widgets.append(b) + b.pack(anchor=tk.NW, padx=(40, 0), pady=(pady_bus, 0)) + pady_bus = 20 + connections = voltage_level.get_bus_connections(self.bus_view, bus_id) + for connection in connections: + c = pw.Connection(self.interior, connection, self.navigate_command) + self.widgets.append(c) + c.pack(anchor=tk.NW, padx=(60, 0)) + if connection == selection_connection: + c.update() + logging.info(f'{connection.equipment_id} is selected connection. {c.winfo_geometry()}') + selected_connection_y = c.winfo_y() + c.highlight() + self.interior.update() + self.canvas.update() + logging.info(f'interior geometry {self.interior.winfo_geometry()}') + logging.info(f'canvas geometry {self.canvas.winfo_geometry()}') + interior_height = self.interior.winfo_height() + canvas_height = self.canvas.winfo_height() + + logging.info( + f'interior_height={interior_height}, canvas_height={canvas_height},' + f' selected_connection_y={selected_connection_y}, ') + if selection_connection and selected_connection_y > (canvas_height / 2) and interior_height: + # the selection is below visible range, scroll to it + y_move_to = (selected_connection_y - canvas_height / 2) / interior_height + logging.info(f'y_move_to={y_move_to}') + self.canvas.yview_moveto(y_move_to) + else: + self.canvas.yview_moveto(0) + logging.info("end drawing") + self.context.reset_selected_connection() + + +if __name__ == "__main__": + + if os.name == 'nt': + # Fixing the blur UI on Windows + from ctypes import windll + + windll.shcore.SetProcessDpiAwareness(2) + root = tk.Tk() + ctx = AppContext(root) + bw = DiagramViewBus(root, ctx, 'Bus-Branch View', BusView.BUS_BRANCH) + bw.pack(fill="both", expand=True) + ctx.network = pn.create_ieee9() + ctx.selection = 'S1' + ctx.selected_tab = bw.tab_name + root.mainloop() diff --git a/yagat/frames/impl/load_flow_parameters.py b/yagat/frames/impl/load_flow_parameters.py new file mode 100644 index 0000000..e73db26 --- /dev/null +++ b/yagat/frames/impl/load_flow_parameters.py @@ -0,0 +1,240 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import logging +import os +import textwrap +import tkinter as tk + +import pypowsybl.loadflow as lf +import tksheet as tks +from pypowsybl._pypowsybl import BalanceType, VoltageInitMode, ConnectedComponentMode + +from yagat.app_context import AppContext + + +class LoadFlowParametersView(tk.Frame): + + def sheet_modified(self, event): + # FIXME: handling of invalid values + if event.eventname == 'edit_table': + row = event.selected.row + column = event.selected.column + new_value = self.sheet[row, column].data + param = self.sheet.get_index_data(row) + lf_parameters = self.context.lf_parameters + if param == 'distributedSlack': + lf_parameters.distributed_slack = new_value + elif param == 'balanceType': + lf_parameters.balance_type = BalanceType.__members__[new_value] + elif param == 'countriesToBalance': + lf_parameters.countries_to_balance = str(new_value).split(',') + elif param == 'voltageInitMode': + lf_parameters.voltage_init_mode = VoltageInitMode.__members__[new_value] + elif param == 'readSlackBus': + lf_parameters.read_slack_bus = new_value + elif param == 'writeSlackBus': + lf_parameters.write_slack_bus = new_value + elif param == 'useReactiveLimits': + lf_parameters.use_reactive_limits = new_value + elif param == 'phaseShifterRegulationOn': + lf_parameters.phase_shifter_regulation_on = new_value + elif param == 'transformerVoltageControlOn': + lf_parameters.transformer_voltage_control_on = new_value + elif param == 'shuntCompensatorVoltageControlOn': + lf_parameters.shunt_compensator_voltage_control_on = new_value + elif param == 'connectedComponentMode': + lf_parameters.connected_component_mode = ConnectedComponentMode.__members__[new_value] + elif param == 'twtSplitShuntAdmittance': + lf_parameters.twt_split_shunt_admittance = new_value + elif param == 'dcUseTransformerRatio': + lf_parameters.dc_use_transformer_ratio = new_value + elif param == 'dcPowerFactor': + lf_parameters.dc_power_factor = new_value + else: + new_value = str(new_value) + lf_parameters.provider_parameters[param] = str(new_value) + logging.info(f'Load Flow Parameter "{param}" set to {new_value}') + logging.info(f'Load Flow Parameters: {lf_parameters}') + + def __init__(self, parent, context: AppContext, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + self.sheet = tks.Sheet(self, index_align='left') + self.sheet.enable_bindings('edit_cell', + 'single_select', + 'drag_select', + 'row_select', + 'column_select', + 'copy', + 'column_width_resize', + 'double_click_column_resize', + 'double_click_row_resize', + 'row_width_resize', + 'column_height_resize', + 'arrowkeys', + ) + self.sheet.bind("<>", self.sheet_modified) + self.context = context + self.variables = [] + + i_row = 0 + self.sheet[i_row, 0].data = 'Enable distributed slack' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.distributed_slack) + self.sheet.set_index_data(r=i_row, value='distributedSlack') + + i_row += 1 + self.sheet[i_row, 0].data = 'Slack distribution balance type' + self.sheet[i_row, 1].dropdown( + values=[BalanceType.PROPORTIONAL_TO_GENERATION_P.name, + BalanceType.PROPORTIONAL_TO_GENERATION_P_MAX.name, + BalanceType.PROPORTIONAL_TO_GENERATION_PARTICIPATION_FACTOR.name, + BalanceType.PROPORTIONAL_TO_GENERATION_REMAINING_MARGIN.name, + BalanceType.PROPORTIONAL_TO_LOAD.name, + BalanceType.PROPORTIONAL_TO_CONFORM_LOAD.name], + set_value=self.context.lf_parameters.balance_type.name + ) + self.sheet.set_index_data(r=i_row, value='balanceType') + + i_row += 1 + self.sheet[i_row, 0].data = 'Countries to balance' + self.sheet[i_row, 1].data = '' + self.sheet.set_index_data(r=i_row, value='countriesToBalance') + + i_row += 1 + self.sheet[i_row, 0].data = 'Voltage Initialization Mode' + self.sheet[i_row, 1].dropdown( + values=[VoltageInitMode.UNIFORM_VALUES.name, + VoltageInitMode.DC_VALUES.name, + VoltageInitMode.PREVIOUS_VALUES.name], + set_value=self.context.lf_parameters.voltage_init_mode.name + ) + self.sheet.set_index_data(r=i_row, value='voltageInitMode') + + i_row += 1 + self.sheet[i_row, 0].data = 'Read slack bus' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.read_slack_bus) + self.sheet.set_index_data(r=i_row, value='readSlackBus') + + i_row += 1 + self.sheet[i_row, 0].data = 'Write slack bus' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.write_slack_bus) + self.sheet.set_index_data(r=i_row, value='writeSlackBus') + + i_row += 1 + self.sheet[i_row, 0].data = 'Use reactive limits' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.use_reactive_limits) + self.sheet.set_index_data(r=i_row, value='useReactiveLimits') + + i_row += 1 + self.sheet[i_row, 0].data = 'Enable Phase Shifter control' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.phase_shifter_regulation_on) + self.sheet.set_index_data(r=i_row, value='phaseShifterRegulationOn') + + i_row += 1 + self.sheet[i_row, 0].data = 'Enable Transformer Voltage control' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.transformer_voltage_control_on) + self.sheet.set_index_data(r=i_row, value='transformerVoltageControlOn') + + i_row += 1 + self.sheet[i_row, 0].data = 'Enable Shunt Compensator Voltage control' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.shunt_compensator_voltage_control_on) + self.sheet.set_index_data(r=i_row, value='shuntCompensatorVoltageControlOn') + + i_row += 1 + self.sheet[i_row, 0].data = 'Connected component mode' + self.sheet[i_row, 1].dropdown( + values=[ConnectedComponentMode.MAIN.name, + ConnectedComponentMode.ALL.name], + set_value=self.context.lf_parameters.connected_component_mode.name + ) + self.sheet.set_index_data(r=i_row, value='connectedComponentMode') + + i_row += 1 + self.sheet[i_row, 0].data = 'Split transformers shunt admittance' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.twt_split_shunt_admittance) + self.sheet.set_index_data(r=i_row, value='twtSplitShuntAdmittance') + + i_row += 1 + self.sheet[i_row, 0].data = 'Ratio of transformers should be used in the flow equations in a DC power flow' + self.sheet[i_row, 1].checkbox(checked=self.context.lf_parameters.dc_use_transformer_ratio) + self.sheet.set_index_data(r=i_row, value='dcUseTransformerRatio') + + i_row += 1 + self.sheet[ + i_row, 0].data = 'Power factor used to convert current limits into active power limits in DC calculations' + self.sheet[i_row, 1].data = self.context.lf_parameters.dc_power_factor + self.sheet.set_index_data(r=i_row, value='dcPowerFactor') + self.sheet.format_cell(i_row, 1, formatter_options=tks.float_formatter(decimals=5)) + + for param_idx, param_s in lf.get_provider_parameters().iterrows(): + i_col = -1 + i_row += 1 + param_name = str(param_idx) + param_description = param_s.description + param_type = param_s.type + param_default = param_s.default + if param_default == '[]': + param_default = '' + param_possible_values = None + if param_s.possible_values and param_s.possible_values != '[]': + param_possible_values = param_s.possible_values[1:-1].split(', ') + + i_col += 1 + self.sheet[i_row, i_col].data = '\n'.join(textwrap.wrap(param_description)) + self.sheet.set_index_data(r=i_row, value=param_name) + + i_col += 1 + if param_type == 'BOOLEAN': + self.sheet[i_row, i_col].checkbox(checked=param_default.lower() == 'true') + elif param_type == 'STRING': + if param_possible_values: + self.sheet[i_row, i_col].dropdown( + values=param_possible_values, + set_value=param_default, + ) + else: + self.sheet[i_row, i_col].data = param_default + elif param_type == 'STRING_LIST': + # FIXME: make use of param_possible_values. + # tksheet does not support multiple selection in dropdown. + # also careful of OLF param where order is significant such as voltageTargetPriorities. + if param_default.startswith('[') and param_default.endswith(']'): + # clean it, we should fix this in OLF + param_default = param_default[1:-1] + self.sheet[i_row, i_col].data = param_default + elif param_type == 'INTEGER': + self.sheet[i_row, i_col].data = param_default + self.sheet.format_cell(i_row, i_col, formatter_options=tks.int_formatter()) + elif param_type == 'DOUBLE': + self.sheet[i_row, i_col].data = param_default + self.sheet.format_cell(i_row, i_col, formatter_options=tks.float_formatter(decimals=5)) + + self.sheet.set_header_data(c=0, value="Description") + self.sheet["A"].readonly(readonly=True) + self.sheet.set_header_data(c=1, value="Value") + self.sheet.set_all_cell_sizes_to_text() + self.sheet.set_index_width(300) + self.sheet.pack(fill="both", expand=True) + + +if __name__ == "__main__": + if os.name == 'nt': + # Fixing the blur UI on Windows + from ctypes import windll + + windll.shcore.SetProcessDpiAwareness(2) + root = tk.Tk() + # Windows & OSX + root.unbind_class("TCombobox", "") + + # Linux and other *nix systems: + root.unbind_class("TCombobox", "") + root.unbind_class("TCombobox", "") + ctx = AppContext(root) + lfpv = LoadFlowParametersView(root, ctx) + lfpv.pack(fill="both", expand=True) + root.mainloop() diff --git a/yagat/frames/impl/main_application.py b/yagat/frames/impl/main_application.py new file mode 100644 index 0000000..1bb6f25 --- /dev/null +++ b/yagat/frames/impl/main_application.py @@ -0,0 +1,80 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import logging +import tkinter as tk +import traceback +from tkinter.messagebox import showerror + +import yagat +from yagat.app_context import AppContext +from yagat.frames.impl.tree_and_diagram import TreeAndDiagram +from yagat.frames.impl.status_bar import StatusBar +from yagat.frames.impl.load_flow_parameters import LoadFlowParametersView +from yagat.menus import MenuBar +from yagat.utils import get_centered_geometry + + +class MainApplication(tk.Frame): + + @staticmethod + def show_error(*args): + logging.exception('Exception occurred') + err = traceback.format_exception(*args) + showerror(type(args[1]).__name__ + ' 😢: ' + str(args[1]), ''.join(err)) + + def __init__(self, parent, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + self.parent = parent + self.parent.report_callback_exception = self.show_error + # disable tear-off menus + self.parent.option_add('*tearOff', False) + self.parent.title('YAGAT v' + yagat.__version__) + self.parent.geometry(get_centered_geometry(parent, 1000, 600)) + self.context = AppContext(parent) + + self.context.add_view_changed_listener(self.on_view_changed) + + self.menubar = MenuBar(self, self.context) + self.parent.config(menu=self.menubar) + + # the container is where we'll stack a bunch of frames + # on top of each other, then the one we want visible + # will be raised above the others + self.container = container = tk.Frame(self.parent) + container.pack(side="top", fill="both", expand=True) + container.grid_rowconfigure(0, weight=1) + container.grid_columnconfigure(0, weight=1) + + self.frames = {} + + self.tree_and_diagram = TreeAndDiagram(container, self.context) + self.tree_and_diagram.paned_window.grid(row=0, column=0, sticky="nsew") + + self.lfp = LoadFlowParametersView(container, self.context) + self.lfp.grid(row=0, column=0, sticky="nsew") + + self.tree_and_diagram.paned_window.tkraise() + + self.statusbar = StatusBar(self.parent, self.context) + self.statusbar.pack(fill=tk.X) + + def on_view_changed(self, new_view): + if new_view == 'Diagram': + self.tree_and_diagram.paned_window.tkraise() + elif new_view == 'LoadFlowParameters': + self.lfp.tkraise() + else: + raise ValueError(f'Unknown view {new_view}') + + +if __name__ == "__main__": + root = tk.Tk() + # disable tear-off menus + root.option_add('*tearOff', False) + MainApplication(root) + root.mainloop() diff --git a/yagat/frames/impl/splash_screen.py b/yagat/frames/impl/splash_screen.py new file mode 100644 index 0000000..33e65bb --- /dev/null +++ b/yagat/frames/impl/splash_screen.py @@ -0,0 +1,31 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import os +import tkinter as tk + +from yagat import get_app_path, __version__ +from yagat.utils import get_centered_geometry + + +class SplashScreen(tk.Frame): + def __init__(self, parent, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + parent.overrideredirect(True) + parent.geometry(get_centered_geometry(parent, 403, 302)) + splash_canvas = tk.Canvas(parent) + splash_canvas.pack(fill="both", expand=True) + self.img = tk.PhotoImage(file=os.path.join(get_app_path(), 'images/splash.png')) + splash_canvas.create_image(0, 0, image=self.img, anchor=tk.NW) + splash_canvas.create_text(10, 10, text='Yet Another Grid Analysis Tool', fill="black", anchor=tk.NW) + splash_canvas.create_text(10, 30, text=f'YAGAT v{__version__}', fill="black", anchor=tk.NW) + + +if __name__ == "__main__": + root = tk.Tk() + SplashScreen(root) + root.mainloop() diff --git a/yagat/frames/impl/status_bar.py b/yagat/frames/impl/status_bar.py new file mode 100644 index 0000000..cf3d99c --- /dev/null +++ b/yagat/frames/impl/status_bar.py @@ -0,0 +1,33 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk +from tkinter import ttk + +from yagat.app_context import AppContext + + +class StatusBar(tk.Frame): + def __init__(self, parent, context: AppContext, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + self.context = context + self.sizegrip = ttk.Sizegrip(self) + self.sizegrip.pack(side=tk.LEFT) + self.statusbar = ttk.Label(parent, text='Ready', borderwidth=1, relief=tk.SUNKEN) + self.statusbar.pack(side=tk.LEFT, fill=tk.X, expand=True) + self.context.add_status_text_listener(lambda value: self.statusbar.config(text=value)) + + +if __name__ == "__main__": + root = tk.Tk() + # disable tear-off menus + root.option_add('*tearOff', False) + ctx = AppContext(root) + label = ttk.Label(root, text='app goes here') + label.pack(expand=True, fill=tk.BOTH) + StatusBar(root, ctx).pack(fill=tk.X) + root.mainloop() diff --git a/yagat/frames/impl/tree_and_diagram.py b/yagat/frames/impl/tree_and_diagram.py new file mode 100644 index 0000000..0acdcda --- /dev/null +++ b/yagat/frames/impl/tree_and_diagram.py @@ -0,0 +1,36 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk + +from yagat.app_context import AppContext +from yagat.frames.impl.diagram_view import DiagramView +from yagat.frames.impl.tree_view import TreeView + + +class TreeAndDiagram(tk.Frame): + def __init__(self, parent, context, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + self.parent = parent + self.context = context + + self.paned_window = tk.PanedWindow(self.parent, orient=tk.HORIZONTAL, showhandle=False, sashrelief=tk.RAISED, + sashpad=4, sashwidth=8) + + self.tree_view = TreeView(self.paned_window, self.context) + self.right_frame = DiagramView(self.paned_window, self.context) + + self.paned_window.add(self.tree_view) + self.paned_window.add(self.right_frame) + + +if __name__ == "__main__": + root = tk.Tk() + ctx = AppContext(root) + v = TreeAndDiagram(root, ctx) + v.paned_window.pack(fill=tk.BOTH, expand=True) + root.mainloop() diff --git a/yagat/frames/impl/tree_view.py b/yagat/frames/impl/tree_view.py new file mode 100644 index 0000000..0cf85f9 --- /dev/null +++ b/yagat/frames/impl/tree_view.py @@ -0,0 +1,169 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import logging +import threading +import tkinter as tk +from tkinter import ttk +from typing import Dict, Union, Optional + +import pypowsybl.network as pn + +import yagat.networkstructure as ns +from yagat.app_context import AppContext + + +class TreeView(tk.Frame): + def __init__(self, parent, context: AppContext, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + self.context = context + + self.search_var = tk.StringVar() + self.search_var.trace_add(mode='write', callback=lambda _1, _2, _3: self.on_search()) + self.search = ttk.Entry(self, textvariable=self.search_var) + self.search.pack(side=tk.TOP, fill=tk.X) + + # show='tree' => will not show header + # selectmode='browse' => single item + self.tree = ttk.Treeview(self, show='tree', selectmode='browse') + self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) + self.tree_parent = None + self.nodes_mapping: Dict[Union['ns.Substation', 'ns.VoltageLevel'], str] = {} + self.selection_mapping: Dict[str, str] = {} + + self.scrollbar = ttk.Scrollbar(self, orient="vertical", command=self.tree.yview) + self.tree.configure(yscrollcommand=self.scrollbar.set) + self.scrollbar.pack(side=tk.LEFT, fill=tk.Y) + context.add_network_changed_listener(self.on_network_changed) + self.tree.bind("<>", self.on_tree_select) + + self.search_thread = None + self.search_pending = False + self.context.add_selection_changed_listener(self.on_selection_changed) + + def on_selection_changed(self, selection: tuple[Optional[str], Optional[str], Optional[ns.Connection]]): + _, selection_id, _ = selection + if not selection_id: + return + + existing_selection = None + tree_selection = [self.tree.item(item)["values"] for item in self.tree.selection()] + if tree_selection and tree_selection[0] != '': + existing_selection = tree_selection[0][1] + if selection_id != existing_selection: + node = self.selection_mapping[selection_id] + self.tree.focus(node) + self.tree.selection_set(node) + self.tree.see(node) + + def on_search(self): + if self.search_thread is not None: + self.search_pending = True + return + to_reattach = [] + self.search_thread = threading.Thread(target=self.on_search_background, args=(to_reattach,)) + self.search_thread.start() + + def schedule_check(t): + self.after(200, check_if_done, t) + + def check_if_done(t): + if not t.is_alive(): + logging.info("Updating tree view...") + self._detach_all() + for item, parent, index in to_reattach: + self.tree.reattach(item, parent, index) + logging.info("Done updating tree view") + self.search_thread = None + if self.search_pending: + self.search_pending = False + self.on_search() + else: + schedule_check(t) + + schedule_check(self.search_thread) + + def on_search_background(self, to_reattach): + if not self.tree_parent: + return + to_search = self.search_var.get().lower() + + included_substations, included_voltage_levels = self._get_included(to_search) + + index = -1 + for substation in self.context.network_structure.substations: + if substation in included_substations: + index += 1 + to_reattach.append((self.nodes_mapping[substation], self.tree_parent, index)) + + for voltage_level in self.context.network_structure.voltage_levels: + if voltage_level in included_voltage_levels: + voltage_level_node = self.nodes_mapping[voltage_level] + parent_node = self.tree_parent + if voltage_level.substation: + parent_node = self.nodes_mapping[voltage_level.substation] + index += 1 + to_reattach.append((voltage_level_node, parent_node, index)) + + def _get_included(self, to_search): + logging.info(f'Searching {to_search}...') + included_substations = set() + for substation in self.context.network_structure.substations: + if to_search in substation.substation_id.lower() or to_search in substation.name.lower(): + included_substations.add(substation) + included_voltage_levels = set() + for voltage_level in self.context.network_structure.voltage_levels: + if to_search in voltage_level.voltage_level_id.lower() or to_search in voltage_level.name.lower(): + included_voltage_levels.add(voltage_level) + if voltage_level.substation: + included_substations.add(voltage_level.substation) + logging.info( + f'Searching {to_search}: {len(included_substations)} substations, ' + f'{len(included_voltage_levels)} voltage levels') + return included_substations, included_voltage_levels + + def _detach_all(self): + for level_1_item in self.tree.get_children(self.tree_parent): + for level_2_item in self.tree.get_children(level_1_item): + self.tree.detach(level_2_item) + self.tree.detach(level_1_item) + + def on_network_changed(self, network: pn.Network): + self.tree.delete(*self.tree.get_children()) + self.tree_parent = None + if not network: + return + self.tree_parent = self.tree.insert('', 'end', text=network.name, open=True) + + for substation in self.context.network_structure.substations: + node = self.tree.insert(self.tree_parent, "end", text=f"{substation.name} ({substation.substation_id})", + values=['substation', substation.substation_id], open=True) + self.nodes_mapping[substation] = node + self.selection_mapping[substation.substation_id] = node + + for voltage_level in self.context.network_structure.voltage_levels: + parent_node = self.tree_parent + if voltage_level.substation: + parent_node = self.nodes_mapping[voltage_level.substation] + node = self.tree.insert(parent_node, "end", text=f"{voltage_level.name} ({voltage_level.voltage_level_id})", + values=['voltage_level', voltage_level.voltage_level_id]) + self.nodes_mapping[voltage_level] = node + self.selection_mapping[voltage_level.voltage_level_id] = node + + def on_tree_select(self, event): + tree = event.widget + selection = [tree.item(item)["values"] for item in tree.selection()] + if selection and selection[0] != '' and selection[0][1] != self.context.selection[1]: + self.context.selection = (selection[0][0], selection[0][1], None) + + +if __name__ == "__main__": + root = tk.Tk() + ctx = AppContext(root) + TreeView(root, ctx).pack(fill="both", expand=True) + ctx.network = pn.create_ieee9() + root.mainloop() diff --git a/yagat/frames/impl/vertical_scrolled_frame.py b/yagat/frames/impl/vertical_scrolled_frame.py new file mode 100644 index 0000000..70706d5 --- /dev/null +++ b/yagat/frames/impl/vertical_scrolled_frame.py @@ -0,0 +1,105 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk +from tkinter import ttk + + +# https://stackoverflow.com/questions/16188420/tkinter-scrollbar-for-frame +# Based on +# https://web.archive.org/web/20170514022131id_/http://tkinter.unpythonic.net/wiki/VerticalScrolledFrame + +class VerticalScrolledFrame(ttk.Frame): + """A pure Tkinter scrollable frame that actually works! + * Use the 'interior' attribute to place widgets inside the scrollable frame. + * Construct and pack/place/grid normally. + * This frame only allows vertical scrolling. + """ + + def __init__(self, parent, *args, **kw): + ttk.Frame.__init__(self, parent, *args, **kw) + + # Create a canvas object and a vertical scrollbar for scrolling it. + self.vsb = ttk.Scrollbar(self, orient=tk.VERTICAL) + self.vsb.pack(fill=tk.Y, side=tk.RIGHT, expand=tk.FALSE) + self.canvas = canvas = tk.Canvas(self, bd=0, highlightthickness=0, + yscrollcommand=self.vsb.set) + canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=tk.TRUE) + self.vsb.config(command=canvas.yview) + + # Reset the view + canvas.xview_moveto(0) + canvas.yview_moveto(0) + + events = ['', '', ''] + + def bind(): + for e in events: + canvas.bind_all(e, self._on_mousewheel) + + def unbind(): + for e in events: + canvas.unbind_all(e) + + # Activate / deactivate mousewheel scrolling when cursor is over / not over the canvas. + canvas.bind("", lambda _: bind()) + canvas.bind("", lambda _: unbind()) + + # Create a frame inside the canvas which will be scrolled with it. + self.interior = interior = ttk.Frame(canvas) + interior_id = canvas.create_window(0, 0, window=interior, + anchor=tk.NW) + + # Track changes to the canvas and frame width and sync them, + # also updating the scrollbar. + def _configure_interior(event): + # Update the scrollbars to match the size of the inner frame. + size = (interior.winfo_reqwidth(), interior.winfo_reqheight()) + canvas.config(scrollregion="0 0 %s %s" % size) + if interior.winfo_reqwidth() != canvas.winfo_width(): + # Update the canvas's width to fit the inner frame. + canvas.config(width=interior.winfo_reqwidth()) + + interior.bind('', _configure_interior) + + def _configure_canvas(event): + if interior.winfo_reqwidth() != canvas.winfo_width(): + # Update the inner frame's width to fill the canvas. + canvas.itemconfigure(interior_id, width=canvas.winfo_width()) + + canvas.bind('', _configure_canvas) + + def _on_mousewheel(self, event): + y1, y2 = self.vsb.get() + direction = 0 + # linux / windows / macOS + if event.num == 5 or event.delta == -120 or event.delta == -1: + direction = +1 + if event.num == 4 or event.delta == 120 or event.delta == 1: + direction = -1 + if y1 != 0 or y2 != 1: + self.canvas.yview_scroll(direction, "units") + + +if __name__ == "__main__": + + class SampleApp(tk.Tk): + def __init__(self, *args, **kwargs): + tk.Tk.__init__(self, *args, **kwargs) + + self.frame = VerticalScrolledFrame(self) + self.frame.pack() + self.label = ttk.Label(self, text="Shrink the window to activate the scrollbar.") + self.label.pack() + buttons = [] + for i in range(10): + buttons.append(ttk.Button(self.frame.interior, text="Button " + str(i))) + buttons[-1].pack() + + + app = SampleApp() + app.mainloop() diff --git a/yagat/images/logo.png b/yagat/images/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..1038364ce05a486857303f145df450e90b5c7d7e GIT binary patch literal 75950 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%0AEh18gEMDN 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

0tPBv|M2jqCM4r_EPa)$3nJwiz#m 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 literal 0 HcmV?d00001 diff --git a/yagat/menus/__init__.py b/yagat/menus/__init__.py new file mode 100644 index 0000000..07d8964 --- /dev/null +++ b/yagat/menus/__init__.py @@ -0,0 +1,8 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from .impl.bar import MenuBar diff --git a/yagat/menus/impl/__init__.py b/yagat/menus/impl/__init__.py new file mode 100644 index 0000000..65327b4 --- /dev/null +++ b/yagat/menus/impl/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# diff --git a/yagat/menus/impl/bar.py b/yagat/menus/impl/bar.py new file mode 100644 index 0000000..3eaa1e3 --- /dev/null +++ b/yagat/menus/impl/bar.py @@ -0,0 +1,22 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk + +from .file import FileMenu +from .help import HelpMenu +from .run import RunMenu +from .view import ViewMenu + + +class MenuBar(tk.Menu): + def __init__(self, parent, context, *args, **kwargs): + tk.Menu.__init__(self, parent, *args, **kwargs) + self.file_menu = FileMenu(self, context) + self.run_menu = RunMenu(self, context) + self.view_menu = ViewMenu(self, context) + self.help_menu = HelpMenu(self) diff --git a/yagat/menus/impl/file.py b/yagat/menus/impl/file.py new file mode 100644 index 0000000..b86bfb8 --- /dev/null +++ b/yagat/menus/impl/file.py @@ -0,0 +1,83 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk +from tkinter import filedialog as fd + +import pypowsybl as pp +import pypowsybl.network as pn + +from yagat.app_context import AppContext + + +class FileMenu(tk.Menu): + def __init__(self, parent, context: AppContext, *args, **kwargs): + tk.Menu.__init__(self, parent, *args, **kwargs) + + self.parent = parent + self.context = context + + parent.add_cascade( + label="File", + menu=self, + underline=0, + ) + + self.add_command(label='Open...', command=self.open_network) + + self.sample_networks_menu = tk.Menu(self) + self.add_cascade(label='Open sample network', menu=self.sample_networks_menu) + + def load_sample_network(network: pn.Network): + context.network = network + context.status_text = 'Network ' + network.name + ' loaded' + + self.sample_networks_menu.add_command(label='IEEE 9 Bus', + command=lambda: load_sample_network(pn.create_ieee9())) + self.sample_networks_menu.add_command(label='IEEE 14 Bus', + command=lambda: load_sample_network(pn.create_ieee14())) + self.sample_networks_menu.add_command(label='IEEE 30 Bus', + command=lambda: load_sample_network(pn.create_ieee30())) + self.sample_networks_menu.add_command(label='IEEE 57 Bus', + command=lambda: load_sample_network(pn.create_ieee57())) + self.sample_networks_menu.add_command(label='IEEE 118 Bus', + command=lambda: load_sample_network(pn.create_ieee118())) + self.sample_networks_menu.add_command(label='IEEE 300 Bus', + command=lambda: load_sample_network(pn.create_ieee300())) + self.sample_networks_menu.add_command(label='CGMES MicroGrid BE', + command=lambda: load_sample_network(pn.create_micro_grid_be_network())) + self.sample_networks_menu.add_command(label='CGMES MicroGrid NL', + command=lambda: load_sample_network(pn.create_micro_grid_nl_network())) + self.sample_networks_menu.add_command(label='PowSyBl Metrix 6 Bus', command=lambda: load_sample_network( + pn.create_metrix_tutorial_six_buses_network())) + self.sample_networks_menu.add_command(label='Eurostag Tutorial', command=lambda: load_sample_network( + pn.create_eurostag_tutorial_example1_network())) + self.sample_networks_menu.add_command(label='Eurostag Tutorial with power limits', + command=lambda: load_sample_network( + pn.create_eurostag_tutorial_example1_with_power_limits_network())) + self.sample_networks_menu.add_command(label='Four Substations Node-Breaker', + command=lambda: load_sample_network( + pn.create_four_substations_node_breaker_network())) + self.sample_networks_menu.add_command(label='Four Substations Node-Breaker with extensions', + command=lambda: load_sample_network( + pn.create_four_substations_node_breaker_network_with_extensions())) + + self.add_separator() + self.add_command( + label='Exit', + command=context.tk_root.destroy, + underline=1, + ) + + def open_network(self): + filename = fd.askopenfilename() + if not filename: + self.context.status_text = 'File opening cancelled by user' + else: + self.context.status_text = 'Opening ' + filename + self.context.network = pp.network.load(filename) + self.context.status_text = 'Network ' + self.context.network.name + ' loaded' diff --git a/yagat/menus/impl/help.py b/yagat/menus/impl/help.py new file mode 100644 index 0000000..b24f05b --- /dev/null +++ b/yagat/menus/impl/help.py @@ -0,0 +1,26 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk +from tkinter.messagebox import showinfo + +import pypowsybl + +import yagat + + +class HelpMenu(tk.Menu): + def __init__(self, parent, *args, **kwargs): + tk.Menu.__init__(self, parent, *args, **kwargs) + + self.parent = parent + parent.add_cascade(label="Help", menu=self) + self.add_command(label='About...', command=lambda: showinfo('About YAGAT', + 'Yet Another Grid Analysis Tool' + + '\nhttps://github.com/jeandemanged/yagat/wiki' + + '\nYAGAT v' + yagat.__version__ + + '\nBased on PyPowSyBl v' + pypowsybl.__version__)) diff --git a/yagat/menus/impl/run.py b/yagat/menus/impl/run.py new file mode 100644 index 0000000..7ebbd17 --- /dev/null +++ b/yagat/menus/impl/run.py @@ -0,0 +1,33 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk + +import pypowsybl.loadflow as lf +import pypowsybl.report as pr + +from yagat.app_context import AppContext + + +class RunMenu(tk.Menu): + def __init__(self, parent, context: AppContext, *args, **kwargs): + tk.Menu.__init__(self, parent, *args, **kwargs) + + self.parent = parent + self.context = context + parent.add_cascade(label="Run", menu=self) + self.add_command(label='Load Flow', command=self.run_load_flow) + + def run_load_flow(self): + reporter = pr.Reporter() + self.context.status_text = 'Starting Load Flow' + results = lf.run_ac(self.context.network, parameters=self.context.lf_parameters, reporter=reporter) + self.context.status_text = 'Load Flow completed' + self.context.network_structure.refresh() + self.context.notify_selection_changed() # hack to trigger refresh + print(results) + print(reporter) diff --git a/yagat/menus/impl/view.py b/yagat/menus/impl/view.py new file mode 100644 index 0000000..d3b835a --- /dev/null +++ b/yagat/menus/impl/view.py @@ -0,0 +1,28 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk + +from yagat.app_context import AppContext + + +class ViewMenu(tk.Menu): + def __init__(self, parent, context: AppContext, *args, **kwargs): + tk.Menu.__init__(self, parent, *args, **kwargs) + + self.parent = parent + self.context = context + parent.add_cascade(label="View", menu=self) + self.add_command(label='Diagram', command=self.view_diagram) + self.add_separator() + self.add_command(label='Load Flow Parameters', command=self.view_load_flow_parameters) + + def view_diagram(self): + self.context.selected_view = 'Diagram' + + def view_load_flow_parameters(self): + self.context.selected_view = 'LoadFlowParameters' diff --git a/yagat/networkstructure/__init__.py b/yagat/networkstructure/__init__.py new file mode 100644 index 0000000..2754618 --- /dev/null +++ b/yagat/networkstructure/__init__.py @@ -0,0 +1,13 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from .impl.bus_views import BusView +from .impl.connection import Connection +from .impl.equipment_type import EquipmentType, ShuntCompensatorType +from .impl.network_structure import NetworkStructure +from .impl.substation import Substation +from .impl.voltage_level import VoltageLevel diff --git a/yagat/networkstructure/impl/__init__.py b/yagat/networkstructure/impl/__init__.py new file mode 100644 index 0000000..65327b4 --- /dev/null +++ b/yagat/networkstructure/impl/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# diff --git a/yagat/networkstructure/impl/bus_views.py b/yagat/networkstructure/impl/bus_views.py new file mode 100644 index 0000000..f7c53c8 --- /dev/null +++ b/yagat/networkstructure/impl/bus_views.py @@ -0,0 +1,13 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from enum import StrEnum + + +class BusView(StrEnum): + BUS_BREAKER = 'BUS_BREAKER' + BUS_BRANCH = 'BUS_BRANCH' diff --git a/yagat/networkstructure/impl/connection.py b/yagat/networkstructure/impl/connection.py new file mode 100644 index 0000000..8a4e295 --- /dev/null +++ b/yagat/networkstructure/impl/connection.py @@ -0,0 +1,98 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import math +from typing import Optional + +import pandas as pd + +import yagat.networkstructure as ns + + +class Connection: + def __init__(self, network_structure: 'ns.NetworkStructure', voltage_level: 'ns.VoltageLevel', equipment_id: str, + equipment_type: 'ns.EquipmentType', + side: Optional[int] = None, name: Optional[str] = None): + self._network_structure = network_structure + self._voltage_level = voltage_level + self._equipment_id = equipment_id + self._name = name + self._equipment_type = equipment_type + self._side = side + + @property + def equipment_id(self) -> str: + return self._equipment_id + + @property + def name(self) -> str: + if self._name: + return self._name + return self._equipment_id + + @property + def equipment_type(self) -> 'ns.EquipmentType': + return self._equipment_type + + @property + def side(self) -> int: + return self._side + + @property + def voltage_level(self) -> 'ns.VoltageLevel': + return self._voltage_level + + @property + def substation(self) -> 'Optional[ns.Substation]': + return self._voltage_level.substation + + @property + def network_structure(self) -> 'ns.NetworkStructure': + return self._network_structure + + def _side_char(self): + if not self.side: + return '' + return f'{self.side}' + + def get_bus_id(self, bus_view: 'ns.BusView') -> str: + if self.equipment_type == ns.EquipmentType.SWITCH: + if bus_view == ns.BusView.BUS_BRANCH: + return '' + elif bus_view == ns.BusView.BUS_BREAKER: + if self.network_structure.is_retained(self): + # omg + return self.network_structure.network.get_bus_breaker_topology(self.voltage_level.voltage_level_id).switches.loc[self.equipment_id][f'bus{self._side_char()}_id'] + else: + return '' + prefix = '' + if bus_view == ns.BusView.BUS_BREAKER: + prefix = 'bus_breaker_' + return self.get_data()[f'{prefix}bus{self._side_char()}_id'] + + def get_p(self) -> float: + if self.equipment_type == ns.EquipmentType.SWITCH: + return math.nan + return self.get_data()[f'p{self._side_char()}'] + + def get_q(self) -> float: + if self.equipment_type == ns.EquipmentType.SWITCH: + return math.nan + return self.get_data()[f'q{self._side_char()}'] + + def get_i(self) -> float: + if self.equipment_type == ns.EquipmentType.SWITCH: + return math.nan + return self.get_data()[f'i{self._side_char()}'] + + def get_connected(self) -> bool: + if self.equipment_type == ns.EquipmentType.SWITCH: + return True + return self.get_data()[f'connected{self._side_char()}'] + + def get_data(self) -> pd.Series: + return self.network_structure.get_connection_data(self.equipment_id, self.side) diff --git a/yagat/networkstructure/impl/equipment_type.py b/yagat/networkstructure/impl/equipment_type.py new file mode 100644 index 0000000..8524fda --- /dev/null +++ b/yagat/networkstructure/impl/equipment_type.py @@ -0,0 +1,37 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from enum import StrEnum + + +class EquipmentType(StrEnum): + LOAD = 'LOAD' + GENERATOR = 'GENERATOR' + LINE = 'LINE' + TWO_WINDINGS_TRANSFORMER = 'TWO_WINDINGS_TRANSFORMER' + THREE_WINDINGS_TRANSFORMER = 'THREE_WINDINGS_TRANSFORMER' + DANGLING_LINE = 'DANGLING_LINE' + STATIC_VAR_COMPENSATOR = 'STATIC_VAR_COMPENSATOR' + SHUNT_COMPENSATOR = 'SHUNT_COMPENSATOR' + LCC_CONVERTER_STATION = 'LCC_CONVERTER_STATION' + VSC_CONVERTER_STATION = 'VSC_CONVERTER_STATION' + SWITCH = 'SWITCH' + + @staticmethod + def branch_types(): + return [EquipmentType.LINE, EquipmentType.TWO_WINDINGS_TRANSFORMER] + + @staticmethod + def injection_types(): + return [EquipmentType.LOAD, EquipmentType.GENERATOR, EquipmentType.SHUNT_COMPENSATOR, + EquipmentType.DANGLING_LINE, EquipmentType.STATIC_VAR_COMPENSATOR, EquipmentType.LCC_CONVERTER_STATION, + EquipmentType.VSC_CONVERTER_STATION] + + +class ShuntCompensatorType(StrEnum): + CAPACITOR = 'CAPACITOR' + REACTOR = 'REACTOR' diff --git a/yagat/networkstructure/impl/network_structure.py b/yagat/networkstructure/impl/network_structure.py new file mode 100644 index 0000000..1b96382 --- /dev/null +++ b/yagat/networkstructure/impl/network_structure.py @@ -0,0 +1,261 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import logging +from typing import Dict, List, Optional + +import pandas as pd +import pypowsybl.network as pn + +import yagat.networkstructure as ns + + +class NetworkStructure: + def __init__(self, network: pn.Network): + self._network: pn.Network = network + self._substations: Dict[str, ns.Substation] = {} + self._voltage_levels: Dict[str, ns.VoltageLevel] = {} + self._connections: Dict[(str, Optional[int]), ns.Connection] = {} + + self._substations_df: pd.DataFrame = pd.DataFrame() + self._voltage_levels_df: pd.DataFrame = pd.DataFrame() + + self._injections_df: Dict[ns.EquipmentType, pd.DataFrame] = {} + self._branches_df: Dict[ns.EquipmentType, pd.DataFrame] = {} + self._three_windings_transformers_df: pd.DataFrame = pd.DataFrame() + self._tie_lines_df: pd.DataFrame = pd.DataFrame() + self._buses_df: pd.DataFrame = pd.DataFrame() + self._switches_df: pd.DataFrame = pd.DataFrame() + self._hvdc_lines_df: pd.DataFrame = pd.DataFrame() + + self._linear_shunt_compensator_sections_df: pd.DataFrame = pd.DataFrame() + self._non_linear_shunt_compensator_sections_df: pd.DataFrame = pd.DataFrame() + + self.refresh() + + for substation_idx, substation_s in self._substations_df.iterrows(): + substation_id = str(substation_idx) + self._substations[substation_id] = ns.Substation(self, substation_id, str(substation_s['name'])) + + for voltage_level_idx, voltage_level_s in self._voltage_levels_df.iterrows(): + voltage_level_id = str(voltage_level_idx) + substation_id = voltage_level_s.substation_id + substation = None + if substation_id in self._substations: + substation = self._substations[substation_id] + voltage_level = ns.VoltageLevel(self, substation, voltage_level_id, str(voltage_level_s['name'])) + self._voltage_levels[voltage_level_id] = voltage_level + if substation: + substation.add_voltage_level(voltage_level) + + for typ in ns.EquipmentType.branch_types(): + self.__process_branches(self._branches_df[typ], typ) + + for typ in ns.EquipmentType.injection_types(): + self.__process_injection(self._injections_df[typ], typ) + + for three_windings_xf_idx, three_windings_xf_s in self._three_windings_transformers_df.iterrows(): + three_windings_xf_id = str(three_windings_xf_idx) + voltage_level1_id = three_windings_xf_s.voltage_level1_id + voltage_level2_id = three_windings_xf_s.voltage_level2_id + voltage_level3_id = three_windings_xf_s.voltage_level3_id + voltage_level1 = self._voltage_levels[voltage_level1_id] + voltage_level2 = self._voltage_levels[voltage_level2_id] + voltage_level3 = self._voltage_levels[voltage_level3_id] + c1 = ns.Connection(self, voltage_level1, three_windings_xf_id, ns.EquipmentType.THREE_WINDINGS_TRANSFORMER, + 1, + str(three_windings_xf_s['name'])) + c2 = ns.Connection(self, voltage_level2, three_windings_xf_id, ns.EquipmentType.THREE_WINDINGS_TRANSFORMER, + 2, + str(three_windings_xf_s['name'])) + c3 = ns.Connection(self, voltage_level3, three_windings_xf_id, ns.EquipmentType.THREE_WINDINGS_TRANSFORMER, + 3, + str(three_windings_xf_s['name'])) + voltage_level1.add_connection(c1) + voltage_level2.add_connection(c2) + voltage_level3.add_connection(c3) + self._connections[(c1.equipment_id, c1.side)] = c1 + self._connections[(c2.equipment_id, c2.side)] = c2 + self._connections[(c3.equipment_id, c3.side)] = c3 + + for switch_idx, switch_s in self._switches_df.iterrows(): + switch_id = str(switch_idx) + voltage_level_id = switch_s.voltage_level_id + voltage_level = self._voltage_levels[voltage_level_id] + c1 = ns.Connection(self, voltage_level, switch_id, ns.EquipmentType.SWITCH, + 1, + str(switch_s['name'])) + c2 = ns.Connection(self, voltage_level, switch_id, ns.EquipmentType.SWITCH, + 2, + str(switch_s['name'])) + voltage_level.add_connection(c1) + voltage_level.add_connection(c2) + self._connections[(c1.equipment_id, c1.side)] = c1 + self._connections[(c2.equipment_id, c2.side)] = c2 + + @property + def network(self) -> pn.Network: + return self._network + + def refresh(self): + logging.info('refresh start') + self._substations_df = self._network.get_substations(all_attributes=True) + self._voltage_levels_df = self._network.get_voltage_levels(all_attributes=True) + self._three_windings_transformers_df = self._network.get_3_windings_transformers(all_attributes=True) + self._tie_lines_df = self._network.get_tie_lines(all_attributes=True) + self._switches_df = self._network.get_switches(all_attributes=True) + self._injections_df[ns.EquipmentType.LOAD] = self._network.get_loads(all_attributes=True) + self._injections_df[ns.EquipmentType.GENERATOR] = self._network.get_generators(all_attributes=True) + self._injections_df[ns.EquipmentType.DANGLING_LINE] = self._network.get_dangling_lines(all_attributes=True) + self._injections_df[ns.EquipmentType.SHUNT_COMPENSATOR] = self._network.get_shunt_compensators( + all_attributes=True) + self._injections_df[ns.EquipmentType.STATIC_VAR_COMPENSATOR] = self._network.get_static_var_compensators( + all_attributes=True) + self._injections_df[ns.EquipmentType.LCC_CONVERTER_STATION] = self._network.get_lcc_converter_stations( + all_attributes=True) + self._injections_df[ns.EquipmentType.VSC_CONVERTER_STATION] = self._network.get_vsc_converter_stations( + all_attributes=True) + self._branches_df[ns.EquipmentType.LINE] = self._network.get_lines(all_attributes=True) + self._branches_df[ns.EquipmentType.TWO_WINDINGS_TRANSFORMER] = self._network.get_2_windings_transformers( + all_attributes=True) + self._buses_df = self._network.get_buses(all_attributes=True) + self._linear_shunt_compensator_sections_df = self._network.get_linear_shunt_compensator_sections( + all_attributes=True) + self._non_linear_shunt_compensator_sections_df = self._network.get_non_linear_shunt_compensator_sections( + all_attributes=True) + self._hvdc_lines_df = self._network.get_hvdc_lines(all_attributes=True) + logging.info('refresh end') + + def __process_injection(self, injections_df, injection_type: ns.EquipmentType) -> None: + for injection_idx, injection_s in injections_df.iterrows(): + injection_id = str(injection_idx) + voltage_level_id = injection_s.voltage_level_id + voltage_level = self._voltage_levels[voltage_level_id] + c1 = ns.Connection(self, voltage_level, injection_id, injection_type, None, injection_s['name']) + voltage_level.add_connection(c1) + self._connections[(c1.equipment_id, c1.side)] = c1 + + def __process_branches(self, branches_df, branch_type: ns.EquipmentType) -> None: + for branch_idx, branches_s in branches_df.iterrows(): + branch_id = str(branch_idx) + voltage_level1_id = branches_s.voltage_level1_id + voltage_level2_id = branches_s.voltage_level2_id + voltage_level1 = self._voltage_levels[voltage_level1_id] + voltage_level2 = self._voltage_levels[voltage_level2_id] + c1 = ns.Connection(self, voltage_level1, branch_id, branch_type, 1, branches_s['name']) + c2 = ns.Connection(self, voltage_level2, branch_id, branch_type, 2, branches_s['name']) + voltage_level1.add_connection(c1) + voltage_level2.add_connection(c2) + self._connections[(c1.equipment_id, c1.side)] = c1 + self._connections[(c2.equipment_id, c2.side)] = c2 + + @property + def substations(self) -> 'List[ns.Substation]': + return sorted(self._substations.values(), key=lambda s: s.name) + + @property + def voltage_levels(self) -> 'List[ns.VoltageLevel]': + return sorted(self._voltage_levels.values(), key=lambda vl: (-vl.get_data().nominal_v, vl.name)) + + def get_substation(self, substation_id: str) -> 'Optional[ns.Substation]': + if substation_id in self._substations: + return self._substations[substation_id] + return None + + def get_voltage_level(self, voltage_level_id: str) -> 'Optional[ns.VoltageLevel]': + if voltage_level_id in self._voltage_levels: + return self._voltage_levels[voltage_level_id] + return None + + def get_buses(self, voltage_level: 'ns.VoltageLevel') -> pd.DataFrame: + return self._buses_df.loc[self._buses_df['voltage_level_id'] == voltage_level.voltage_level_id] + + def get_substation_or_voltage_level(self, object_id: str) -> '[ns.Substation, ns.VoltageLevel]': + substation = self.get_substation(object_id) + if substation: + return substation + voltage_level = self.get_voltage_level(object_id) + if voltage_level: + return voltage_level + raise RuntimeError(f'{object_id} is not a known Substation or VoltageLevel') + + def get_connection(self, connection_id: str, side: Optional[int]) -> 'Optional[ns.Connection]': + if (connection_id, side) in self._connections: + return self._connections[(connection_id, side)] + return None + + def get_voltage_level_data(self, voltage_level: 'ns.VoltageLevel') -> pd.Series: + return self._voltage_levels_df.loc[voltage_level.voltage_level_id] + + def get_connection_data(self, connection_id: str, side: Optional[int]) -> pd.Series: + connection = self._connections[(connection_id, side)] + if not connection: + return pd.Series() + typ = connection.equipment_type + if typ in ns.EquipmentType.branch_types(): + df = self._branches_df[typ] + elif typ in ns.EquipmentType.injection_types(): + df = self._injections_df[typ] + elif typ == ns.EquipmentType.THREE_WINDINGS_TRANSFORMER: + df = self._three_windings_transformers_df + else: + raise RuntimeError(f'No dataframe for connection {connection_id} of type {typ}') + + return df.loc[connection.equipment_id] + + def get_shunt_compensator_type(self, connection: ns.Connection) -> 'ns.ShuntCompensatorType': + if connection.equipment_type != ns.EquipmentType.SHUNT_COMPENSATOR: + raise RuntimeError('Not a shunt compensator') + model_type = self._injections_df[ns.EquipmentType.SHUNT_COMPENSATOR].loc[connection.equipment_id]['model_type'] + if model_type == 'LINEAR': + b = self._linear_shunt_compensator_sections_df.loc[connection.equipment_id]['b_per_section'] + else: + # just take the first section. it is not supposed to be a different sign across sections. + b = self._non_linear_shunt_compensator_sections_df.loc[(connection.equipment_id, 0)]['b'] + if b > 0: + return ns.ShuntCompensatorType.CAPACITOR + return ns.ShuntCompensatorType.REACTOR + + def is_retained(self, connection: ns.Connection) -> bool: + if connection.equipment_type != ns.EquipmentType.SWITCH: + raise RuntimeError('Not a switch') + return self._switches_df.loc[connection.equipment_id]['retained'] + + def is_open(self, connection: ns.Connection) -> bool: + if connection.equipment_type != ns.EquipmentType.SWITCH: + raise RuntimeError('Not a switch') + return self._switches_df.loc[connection.equipment_id]['open'] + + def get_other_sides(self, connection: ns.Connection) -> List[ns.Connection]: + if connection.equipment_type in ns.EquipmentType.branch_types() or connection.equipment_type == ns.EquipmentType.SWITCH: + other_side_num = 1 if connection.side == 2 else 2 + return [self._connections[(connection.equipment_id, other_side_num)]] + elif connection.equipment_type == ns.EquipmentType.THREE_WINDINGS_TRANSFORMER: + other_sides = [] + for i in range(1, 4): + if i != connection.side and (connection.equipment_id, i) in self._connections: + other_sides.append(self._connections[(connection.equipment_id, i)]) + return other_sides + elif connection.equipment_type == ns.EquipmentType.DANGLING_LINE: + return self._get_other_side_from_df(connection, self._tie_lines_df, 'dangling_line1_id', + 'dangling_line2_id') + elif connection.equipment_type in [ns.EquipmentType.LCC_CONVERTER_STATION, + ns.EquipmentType.VSC_CONVERTER_STATION]: + return self._get_other_side_from_df(connection, self._hvdc_lines_df, 'converter_station1_id', + 'converter_station2_id') + return [] + + def _get_other_side_from_df(self, connection: ns.Connection, data_frame: pd.DataFrame, col1: str, col2: str) -> \ + List[ns.Connection]: + for _, series in data_frame.iterrows(): + eq1 = series[col1] + eq2 = series[col2] + if connection.equipment_id == eq1: + return [self._connections[(eq2, None)]] + elif connection.equipment_id == eq2: + return [self._connections[(eq1, None)]] + return [] diff --git a/yagat/networkstructure/impl/substation.py b/yagat/networkstructure/impl/substation.py new file mode 100644 index 0000000..3922443 --- /dev/null +++ b/yagat/networkstructure/impl/substation.py @@ -0,0 +1,44 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from typing import Dict, List, Optional + +import yagat.networkstructure as ns + + +class Substation: + def __init__(self, network_structure: 'ns.NetworkStructure', substation_id: str, name: Optional[str] = None): + self._network_structure = network_structure + self._substation_id = substation_id + self._name = name + self._voltage_levels: Dict[str, 'ns.VoltageLevel'] = {} + + @property + def network_structure(self) -> 'ns.NetworkStructure': + return self._network_structure + + @property + def substation_id(self) -> str: + return self._substation_id + + @property + def name(self) -> str: + if self._name: + return self._name + return self._substation_id + + @property + def voltage_levels(self) -> List['ns.VoltageLevel']: + return sorted(self._voltage_levels.values(), key=lambda vl: vl.get_data().nominal_v, reverse=True) + + def get_voltage_level(self, voltage_level_id: str) -> Optional['ns.VoltageLevel']: + if voltage_level_id in self._voltage_levels: + return self._voltage_levels[voltage_level_id] + return None + + def add_voltage_level(self, voltage_level: 'ns.VoltageLevel') -> None: + self._voltage_levels[voltage_level.voltage_level_id] = voltage_level diff --git a/yagat/networkstructure/impl/voltage_level.py b/yagat/networkstructure/impl/voltage_level.py new file mode 100644 index 0000000..9f4dc16 --- /dev/null +++ b/yagat/networkstructure/impl/voltage_level.py @@ -0,0 +1,68 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from typing import Dict, List, Optional + +import pandas as pd + +import yagat.networkstructure as ns + + +class VoltageLevel: + def __init__(self, network_structure: 'ns.NetworkStructure', substation: 'Optional[ns.Substation]', + voltage_level_id: str, name: Optional[str] = None): + self._network_structure = network_structure + self._substation = substation + self._voltage_level_id = voltage_level_id + self._name = name + self._connections: Dict[(str, Optional[int]), 'ns.Connection'] = {} + + @property + def voltage_level_id(self) -> str: + return self._voltage_level_id + + @property + def name(self) -> str: + if self._name: + return self._name + return self._voltage_level_id + + @property + def substation(self) -> 'Optional[ns.Substation]': + return self._substation + + @property + def network_structure(self) -> 'ns.NetworkStructure': + return self._network_structure + + def add_connection(self, connection: 'ns.Connection'): + self._connections[(connection.equipment_id, connection.side)] = connection + + @property + def connections(self) -> List['ns.Connection']: + return list(self._connections.values()) + + def get_buses(self, bus_view: 'ns.BusView') -> pd.DataFrame: + bus_branch_buses = self.network_structure.get_buses(self) + match bus_view: + case ns.BusView.BUS_BRANCH: + return bus_branch_buses + case ns.BusView.BUS_BREAKER: + return self.network_structure.network.get_bus_breaker_topology(self.voltage_level_id).buses.join(bus_branch_buses, on='bus_id', rsuffix='_ignore') + + + def get_bus_connections(self, bus_view: 'ns.BusView', bus_id: str) -> List['ns.Connection']: + bus_connections = [c for c in self._connections.values() if c.get_bus_id(bus_view) == bus_id] + return bus_connections + + def get_connection(self, connection_id: str, side: Optional[int] = None) -> Optional['ns.Connection']: + if (connection_id, side) in self._connections: + return self._connections[(connection_id, side)] + return None + + def get_data(self) -> pd.Series: + return self.network_structure.get_voltage_level_data(self) diff --git a/yagat/utils/__init__.py b/yagat/utils/__init__.py new file mode 100644 index 0000000..db36f61 --- /dev/null +++ b/yagat/utils/__init__.py @@ -0,0 +1,9 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from .impl.screen_utils import get_centered_geometry +from .impl.formatting_utils import format_v_mag, format_v_angle, format_power diff --git a/yagat/utils/impl/__init__.py b/yagat/utils/impl/__init__.py new file mode 100644 index 0000000..65327b4 --- /dev/null +++ b/yagat/utils/impl/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# diff --git a/yagat/utils/impl/formatting_utils.py b/yagat/utils/impl/formatting_utils.py new file mode 100644 index 0000000..8cc7a09 --- /dev/null +++ b/yagat/utils/impl/formatting_utils.py @@ -0,0 +1,21 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +def format_v_mag(value: float): + return _repl_nan(f'{value:.2f}') + + +def format_v_angle(value: float): + return _repl_nan(f'{value:.3f}') + + +def format_power(value: float): + return _repl_nan(f'{value:.1f}') + + +def _repl_nan(value: str): + return value.replace('nan', '-') diff --git a/yagat/utils/impl/screen_utils.py b/yagat/utils/impl/screen_utils.py new file mode 100644 index 0000000..c130c44 --- /dev/null +++ b/yagat/utils/impl/screen_utils.py @@ -0,0 +1,30 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import os +import tkinter as tk + + +def get_screen_infos(root: tk.Tk) -> tuple[int, int]: + screen_width = root.winfo_screenwidth() + screen_height = root.winfo_screenheight() + scale = 1.0 + + if os.name == 'nt': + # Fix Tk's winfo not accounting windows scaling + from ctypes import windll + + scale = windll.shcore.GetScaleFactorForDevice(0) / 100 + + return scale * screen_width, scale * screen_height + + +def get_centered_geometry(root: tk.Tk, width: int, height: int) -> str: + screen_width, screen_height = get_screen_infos(root) + x = int((screen_width / 2) - (width / 2)) + y = int((screen_height / 2) - (height / 2)) + return f'{width}x{height}+{x}+{y}' diff --git a/yagat/widgets/__init__.py b/yagat/widgets/__init__.py new file mode 100644 index 0000000..4a918e7 --- /dev/null +++ b/yagat/widgets/__init__.py @@ -0,0 +1,9 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +from .impl.label_value import LabelValue +from .impl.substation import Substation, VoltageLevel, Bus, Connection diff --git a/yagat/widgets/impl/__init__.py b/yagat/widgets/impl/__init__.py new file mode 100644 index 0000000..65327b4 --- /dev/null +++ b/yagat/widgets/impl/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# diff --git a/yagat/widgets/impl/label_value.py b/yagat/widgets/impl/label_value.py new file mode 100644 index 0000000..c89fbec --- /dev/null +++ b/yagat/widgets/impl/label_value.py @@ -0,0 +1,41 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import tkinter as tk +from tkinter import font +from tkinter import ttk +from typing import Optional + + +class LabelValue(tk.Frame): + BOLD_FONT = None + + def __init__(self, parent, label: str, value: tk.StringVar, unit: Optional[str] = None, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + + if not LabelValue.BOLD_FONT: + font_copy = font.nametofont('TkDefaultFont').copy() + font_copy.config(weight='bold') + LabelValue.BOLD_FONT = font_copy + + self._label = ttk.Label(self, text=label) + self._label.pack(side=tk.LEFT) + + self._value_var = value + self._value = ttk.Label(self, textvariable=self._value_var, font=LabelValue.BOLD_FONT) + self._value.pack(side=tk.LEFT) + + if unit: + self._unit = ttk.Label(self, text=unit) + self._unit.pack(side=tk.LEFT) + + +if __name__ == "__main__": + root = tk.Tk() + LabelValue(root, 'label1:', tk.StringVar(value='value1')).pack(side=tk.LEFT) + LabelValue(root, 'label2:', tk.StringVar(value='value2'), 'kV').pack(side=tk.LEFT, padx=10) + root.mainloop() diff --git a/yagat/widgets/impl/substation.py b/yagat/widgets/impl/substation.py new file mode 100644 index 0000000..47427eb --- /dev/null +++ b/yagat/widgets/impl/substation.py @@ -0,0 +1,242 @@ +# +# Copyright (c) 2024, Damien Jeandemange (https://github.com/jeandemanged) +# 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/. +# SPDX-License-Identifier: MPL-2.0 +# +import math +import tkinter as tk + +import pandas as pd +import pypowsybl.network as pn + +import yagat.networkstructure as ns +import yagat.widgets as pw +from yagat.utils import format_v_mag, format_v_angle, format_power + + +class Substation(tk.Frame): + def __init__(self, parent, substation: 'ns.Substation', *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + + self._name_var = tk.StringVar(value=substation.name) + self._name_label = pw.LabelValue(self, 'Substation:', self._name_var) + self._name_label.pack(side=tk.LEFT) + + self._id_var = tk.StringVar(value=substation.substation_id) + self._id_label = pw.LabelValue(self, 'id:', self._id_var) + self._id_label.pack(side=tk.LEFT, padx=(10, 0)) + + +class VoltageLevel(tk.Frame): + def __init__(self, parent, voltage_level: 'ns.VoltageLevel', *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + + self._name_var = tk.StringVar(value=voltage_level.name) + self._name_label = pw.LabelValue(self, 'VoltageLevel:', self._name_var) + self._name_label.pack(side=tk.LEFT) + + self._nominal_v_var = tk.StringVar(value=format_v_mag(voltage_level.get_data().nominal_v)) + self._nominal_v_label = pw.LabelValue(self, 'Nominal voltage:', self._nominal_v_var, 'kV') + self._nominal_v_label.pack(side=tk.LEFT, padx=(10, 0)) + + self._id_var = tk.StringVar(value=voltage_level.voltage_level_id) + self._id_label = pw.LabelValue(self, 'id:', self._id_var) + self._id_label.pack(side=tk.LEFT, padx=(10, 0)) + + +class Bus(tk.Frame): + def __init__(self, parent, bus_id: str, bus_data: pd.Series, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + + self._name_var = tk.StringVar(value=str(bus_data['name'])) + self._name_label = pw.LabelValue(self, 'Bus:', self._name_var) + self._name_label.pack(side=tk.LEFT) + + self._v_mag_var = tk.StringVar(value=format_v_mag(bus_data.v_mag)) + self._v_mag_label = pw.LabelValue(self, 'Vmag:', self._v_mag_var, 'kV') + self._v_mag_label.pack(side=tk.LEFT, padx=(10, 0)) + + self._v_angle_var = tk.StringVar(value=format_v_angle(bus_data.v_angle)) + self._v_angle_label = pw.LabelValue(self, 'Vangle:', self._v_angle_var, '°') + self._v_angle_label.pack(side=tk.LEFT, padx=(10, 0)) + + cc = self.clean_component(bus_data.connected_component) + sc = self.clean_component(bus_data.synchronous_component) + self._component_var = tk.StringVar(value=f'CC{cc} SC{sc}') + self._component_var = pw.LabelValue(self, 'Island:', self._component_var) + self._component_var.pack(side=tk.LEFT, padx=(10, 0)) + + self._id_var = tk.StringVar(value=bus_id) + self._id_label = pw.LabelValue(self, 'id:', self._id_var) + self._id_label.pack(side=tk.LEFT, padx=(10, 0)) + + @staticmethod + def clean_component(component_num): + if math.isnan(component_num): + component_num = '-' + else: + component_num = int(component_num) + return component_num + + +class Connection(tk.Frame): + def __init__(self, parent, connection: 'ns.Connection', navigate_command, *args, **kwargs): + tk.Frame.__init__(self, parent, *args, **kwargs) + + self.canvas = tk.Canvas(self, width=550, height=60, highlightthickness=0) + self.canvas.create_line(0, 0, 0, 60, fill="black", width=15) + self.canvas.create_line(0, 30, 30, 30, fill="black", width=2) + self.connection = connection + self.navigate_command = navigate_command + if connection.equipment_type == ns.EquipmentType.SWITCH: + self.canvas.create_line(30, 30, 50, 30, fill="black", width=2) + else: + if connection.get_connected(): + self.canvas.create_line(30, 30, 50, 30, fill="black", width=3) + else: + self.canvas.create_line(30, 40, 50, 30, fill="black", width=3) + + match connection.equipment_type: + case ns.EquipmentType.LOAD: + self.draw_load() + case ns.EquipmentType.GENERATOR: + self.draw_generator() + case ns.EquipmentType.SHUNT_COMPENSATOR | ns.EquipmentType.STATIC_VAR_COMPENSATOR: + self.draw_shunt() + case ns.EquipmentType.LINE | ns.EquipmentType.DANGLING_LINE: + self.canvas.create_line(50, 30, 500, 30, fill="black", width=2) + self.draw_other_side_button() + case ns.EquipmentType.SWITCH: + self.draw_switch() + self.draw_other_side_button() + case ns.EquipmentType.TWO_WINDINGS_TRANSFORMER: + self.draw_2wt() + self.draw_other_side_button() + case ns.EquipmentType.THREE_WINDINGS_TRANSFORMER: + self.draw_3wt() + other_sides = self.connection.network_structure.get_other_sides(self.connection) + other_side1 = other_sides[0] + other_side2 = other_sides[1] + btn1 = tk.Button(self.canvas, text='>>', command=lambda: navigate_command(other_side1)) + self.canvas.create_window(510, 15, width=30, height=20, anchor=tk.W, window=btn1) + btn2 = tk.Button(self.canvas, text='>>', command=lambda: navigate_command(other_side2)) + self.canvas.create_window(510, 40, width=30, height=20, anchor=tk.W, window=btn2) + case ns.EquipmentType.LCC_CONVERTER_STATION | ns.EquipmentType.VSC_CONVERTER_STATION: + self.draw_dc_converter() + self.draw_other_side_button() + case _: + self.canvas.create_line(50, 30, 500, 30, fill="black", width=2) + + self.canvas.pack(side=tk.LEFT, pady=(0, 0), ipady=0) + + self._name_var = tk.StringVar(value=connection.name) + self._name_label = pw.LabelValue(self, '', self._name_var) + self._name_label.place(x=30, y=5) + + if connection.equipment_type != ns.EquipmentType.SWITCH: + self._p = tk.StringVar(value=format_power(connection.get_p())) + self._p_label = pw.LabelValue(self, '', self._p, 'MW') + self._p_label.place(x=80, y=33) + + self._q = tk.StringVar(value=format_power(connection.get_q())) + self._q_label = pw.LabelValue(self, '', self._q, 'Mvar') + self._q_label.place(x=180, y=33) + + def draw_other_side_button(self): + other_sides = self.connection.network_structure.get_other_sides(self.connection) + if len(other_sides) == 1: + other_side = other_sides[0] + btn = tk.Button(self.canvas, text='>>', command=lambda: self.navigate_command(other_side)) + self.canvas.create_window(510, 30, width=30, height=20, anchor=tk.W, window=btn) + + def draw_dc_converter(self): + self.canvas.create_line(50, 30, 300, 30, fill="black", width=2) + self.canvas.create_rectangle(300, 15, 330, 45, width=2) + self.canvas.create_line(300, 45, 330, 15, fill="black", width=2) + # ac + self.canvas.create_arc(304, 20, 309, 25, start=0, extent=180, width=2, style=tk.ARC) + self.canvas.create_arc(309, 20, 314, 25, start=180, extent=180, width=2, style=tk.ARC) + # dc + self.canvas.create_line(318, 35, 325, 35, fill="black", width=2) + self.canvas.create_line(318, 38, 325, 38, fill="black", width=2) + self.canvas.create_line(330, 30, 500, 30, fill="black", width=2) + + def draw_3wt(self): + self.canvas.create_line(50, 30, 300, 30, fill="black", width=2) + self.canvas.create_oval(300, 20, 320, 40, width=2) + self.canvas.create_oval(310, 15, 330, 35, width=2) + self.canvas.create_oval(310, 25, 330, 45, width=2) + self.canvas.create_line(330, 23, 500, 23, fill="black", width=2) + self.canvas.create_line(330, 37, 500, 37, fill="black", width=2) + + def draw_2wt(self): + self.canvas.create_line(50, 30, 300, 30, fill="black", width=2) + self.canvas.create_oval(300, 20, 320, 40, width=2) + self.canvas.create_oval(310, 20, 330, 40, width=2) + self.canvas.create_line(330, 30, 500, 30, fill="black", width=2) + + def draw_switch(self): + self.canvas.create_line(50, 30, 305, 30, fill="black", width=2) + self.canvas.create_rectangle(305, 20, 325, 40, width=2) + if self.connection.network_structure.is_open(self.connection): + self.canvas.create_line(315, 25, 315, 35, fill="black", width=2) + else: + self.canvas.create_line(310, 30, 320, 30, fill="black", width=2) + self.canvas.create_line(325, 30, 500, 30, fill="black", width=2) + + def draw_shunt(self): + self.canvas.create_line(50, 30, 300, 30, fill="black", width=2) + if self.connection.equipment_type == ns.EquipmentType.SHUNT_COMPENSATOR: + sc_type = self.connection.network_structure.get_shunt_compensator_type(self.connection) + if sc_type == ns.ShuntCompensatorType.CAPACITOR: + self.canvas.create_line(300, 30, 310, 30, fill="black", width=2) + self.canvas.create_line(310, 20, 310, 40, fill="black", width=2) + self.canvas.create_line(320, 20, 320, 40, fill="black", width=2) + self.canvas.create_line(320, 30, 330, 30, fill="black", width=2) + else: + for i in range(3): + self.canvas.create_arc(300 + 10 * i, 20, 300 + 10 * (i + 1), 40, start=0, extent=180, + width=2, style=tk.ARC) + elif self.connection.equipment_type == ns.EquipmentType.STATIC_VAR_COMPENSATOR: + self.canvas.create_rectangle(300, 20, 330, 40, width=2) + self.canvas.create_text(315, 30, text='SVC') + self.canvas.create_line(330, 30, 350, 30, fill="black", width=2) + # ground + self.canvas.create_line(350, 20, 350, 40, fill="black", width=2) + for i in range(6): + self.canvas.create_line(350, 20 + i * 4, 350 + 6, 20 + i * 4 + 6, fill="black", width=1) + + def draw_generator(self): + self.canvas.create_line(50, 30, 300, 30, fill="black", width=2) + self.canvas.create_oval(300, 15, 330, 45, width=2) + self.canvas.create_arc(305, 25, 315, 35, start=0, extent=180, width=1, style=tk.ARC) + self.canvas.create_arc(315, 25, 325, 35, start=180, extent=180, width=1, style=tk.ARC) + + def draw_load(self): + self.canvas.create_line(50, 30, 300, 30, fill="black", width=2) + self.canvas.create_rectangle(300, 20, 330, 40, width=2) + self.canvas.create_line(300, 20, 330, 40, fill="black", width=1) + self.canvas.create_line(330, 20, 300, 40, fill="black", width=1) + + def highlight(self): + # self.canvas.configure(background='light blue') + self.canvas.configure(highlightthickness=2, highlightbackground='blue') + + +if __name__ == "__main__": + root = tk.Tk() + net = pn.create_micro_grid_be_network() + structure = ns.NetworkStructure(net) + sub = structure.get_substation('37e14a0f-5e34-4647-a062-8bfd9305fa9d') + vl = structure.get_voltage_level('469df5f7-058f-4451-a998-57a48e8a56fe') + bus = vl.get_buses(ns.BusView.BUS_BRANCH).loc['469df5f7-058f-4451-a998-57a48e8a56fe_0'] + Substation(root, sub).pack(anchor=tk.NW) + VoltageLevel(root, vl).pack(anchor=tk.NW, padx=20) + Bus(root, '469df5f7-058f-4451-a998-57a48e8a56fe_0', bus).pack(anchor=tk.NW, padx=40) + cn = vl.get_connection('78736387-5f60-4832-b3fe-d50daf81b0a6') + Connection(root, cn, lambda *args: None).pack(anchor=tk.NW, padx=60, pady=(0, 0), ipady=0) + Connection(root, cn, lambda *args: None).pack(anchor=tk.NW, padx=60, pady=(0, 0), ipady=0) + Connection(root, cn, lambda *args: None).pack(anchor=tk.NW, padx=60, pady=(0, 0), ipady=0) + root.mainloop()