VeraGrid 5.6.0__tar.gz → 5.6.2__tar.gz

{veragrid-5.6.0 → veragrid-5.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGrid
-Version: 5.6.0
+Version: 5.6.2
 Summary: VeraGrid is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/VeraGrid
 Author: Santiago Peñate Vera et. Al.

veragrid-5.6.2/VeraGrid/Gui/Diagrams/MapWidget/Injections/map_battery_graphics.py

@@ -0,0 +1,42 @@
+# 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 https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from VeraGridEngine.Devices.Injections.battery import Battery
+from VeraGrid.Gui.Diagrams.MapWidget.Injections.map_injections_template_graphics import MapInjectionTemplateGraphicItem
+
+if TYPE_CHECKING:  # Only imports the below statements during type checking
+    from VeraGrid.Gui.Diagrams.MapWidget.grid_map_widget import GridMapWidget
+
+
+class MapBatteryGraphicItem(MapInjectionTemplateGraphicItem):
+
+    def __init__(self, api_object: Battery,
+                 editor: GridMapWidget,
+                 lat: float,
+                 lon: float,
+                 size: float = 0.8,
+                 draw_labels: bool = True):
+        """
+
+        :param api_object:
+        :param editor:
+        """
+        MapInjectionTemplateGraphicItem.__init__(self,
+                                                 api_object=api_object,
+                                                 editor=editor,
+                                                 lat=lat,
+                                                 lon=lon,
+                                                 size=size,
+                                                 draw_labels=draw_labels)
+
+    @property
+    def api_object(self) -> Battery:
+        """
+
+        :return:
+        """
+        return self._api_object

veragrid-5.6.2/VeraGrid/Gui/Diagrams/MapWidget/Injections/map_external_grid_graphics.py

@@ -0,0 +1,42 @@
+# 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 https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from VeraGrid.Gui.Diagrams.generic_graphics import Square
+from VeraGridEngine.Devices.Injections.external_grid import ExternalGrid
+from VeraGrid.Gui.Diagrams.MapWidget.Injections.map_injections_template_graphics import MapInjectionTemplateGraphicItem
+
+if TYPE_CHECKING:  # Only imports the below statements during type checking
+    from VeraGrid.Gui.Diagrams.MapWidget.grid_map_widget import GridMapWidget
+
+
+class MapExternalGridGraphicItem(MapInjectionTemplateGraphicItem):
+    """
+    ExternalGrid graphic item
+    """
+
+    def __init__(self, api_object: ExternalGrid,
+                 editor: GridMapWidget,
+                 lat: float,
+                 lon: float,
+                 size: float = 0.8,
+                 draw_labels: bool = True):
+        """
+
+        :param api_object:
+        :param editor:
+        """
+        MapInjectionTemplateGraphicItem.__init__(self,
+                                                 api_object=api_object,
+                                                 editor=editor,
+                                                 lat=lat,
+                                                 lon=lon,
+                                                 size=size,
+                                                 draw_labels=draw_labels)
+
+    @property
+    def api_object(self) -> ExternalGrid:
+        return self._api_object

veragrid-5.6.2/VeraGrid/Gui/Diagrams/MapWidget/Injections/map_generator_graphics.py

@@ -0,0 +1,256 @@
+# 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 https://mozilla.org/MPL/2.0/.  
+# SPDX-License-Identifier: MPL-2.0
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+import numpy as np
+from PySide6 import QtWidgets, QtCore
+from PySide6.QtWidgets import QMenu
+from VeraGridEngine.Devices.Injections.generator import Generator
+from VeraGrid.Gui.Diagrams.Editors.generator_editor import GeneratorQCurveEditor
+from VeraGrid.Gui.messages import yes_no_question, info_msg
+from VeraGrid.Gui.Diagrams.MapWidget.Injections.map_injections_template_graphics import MapInjectionTemplateGraphicItem
+from VeraGrid.Gui.SolarPowerWizard.solar_power_wizzard import SolarPvWizard
+from VeraGrid.Gui.WindPowerWizard.wind_power_wizzard import WindFarmWizard
+from VeraGrid.Gui.gui_functions import add_menu_entry
+from VeraGrid.Gui.RmsModelEditor.rms_model_editor_engine import RmsModelEditorGUI
+from VeraGridEngine.enumerations import DeviceType
+
+if TYPE_CHECKING:  # Only imports the below statements during type checking
+    from VeraGrid.Gui.Diagrams.MapWidget.grid_map_widget import GridMapWidget
+
+
+class MapGeneratorGraphicItem(MapInjectionTemplateGraphicItem):
+    """
+    GeneratorGraphicItem
+    """
+
+    def __init__(self, api_object: Generator,
+                 editor: GridMapWidget,
+                 lat: float,
+                 lon: float,
+                 size: float = 0.8,
+                 draw_labels: bool = True):
+        """
+
+        :param api_object:
+        :param editor:
+        """
+        MapInjectionTemplateGraphicItem.__init__(self,
+                                                 api_object=api_object,
+                                                 editor=editor,
+                                                 lat=lat,
+                                                 lon=lon,
+                                                 size=size,
+                                                 draw_labels=draw_labels)
+
+    @property
+    def api_object(self) -> Generator:
+        return self._api_object
+
+    def contextMenuEvent(self, event):
+        """
+        Display context menu
+        @param event:
+        @return:
+        """
+        menu = QMenu()
+        menu.addSection("Generator")
+
+        # add_menu_entry(menu=menu,
+        #                text="Active",
+        #                icon_path="",
+        #                function_ptr=self.enable_disable_toggle,
+        #                checkeable=True,
+        #                checked_value=self.api_object.active)
+
+        add_menu_entry(menu=menu,
+                       text="Voltage control",
+                       icon_path="",
+                       function_ptr=self.enable_disable_control_toggle,
+                       checkeable=True,
+                       checked_value=self.api_object.is_controlled)
+
+        add_menu_entry(menu=menu,
+                       text="Set regulation bus",
+                       icon_path="",
+                       function_ptr=self.set_regulation_bus)
+
+        add_menu_entry(menu=menu,
+                       text="Rms Editor",
+                       function_ptr=self.edit_rms,
+                       icon_path=":/Icons/icons/edit.png")
+
+        add_menu_entry(menu=menu,
+                       text="Qcurve edit",
+                       function_ptr=self.edit_q_curve,
+                       icon_path=":/Icons/icons/edit.png")
+
+        menu.addSeparator()
+
+        add_menu_entry(menu=menu,
+                       text="Plot profiles",
+                       icon_path=":/Icons/icons/plot.png",
+                       function_ptr=self.plot)
+
+        menu.addSeparator()
+
+        add_menu_entry(menu=menu,
+                       text="Solar photovoltaic wizard",
+                       icon_path=":/Icons/icons/solar_power.png",
+                       function_ptr=self.solar_pv_wizard)
+
+        add_menu_entry(menu=menu,
+                       text="Wind farm wizard",
+                       icon_path=":/Icons/icons/wind_power.png",
+                       function_ptr=self.wind_farm_wizard)
+
+        menu.addSeparator()
+
+        add_menu_entry(menu, text='Remove',
+                       icon_path=":/Icons/icons/delete_schematic.png",
+                       function_ptr=self.delete)
+
+        add_menu_entry(menu=menu,
+                       text="Convert to battery",
+                       icon_path=":/Icons/icons/add_batt.png",
+                       function_ptr=self.to_battery)
+
+        add_menu_entry(menu=menu,
+                       text="Change bus",
+                       icon_path=":/Icons/icons/move_bus.png",
+                       function_ptr=self.change_bus)
+
+        menu.exec_(event.screenPos())
+
+    def edit_rms(self):
+        """
+
+        :return:
+        """
+        # load templates
+        templates = self.editor.circuit.rms_models
+
+        # select line templates
+        templ_catalogue = dict()
+        templ_list = []
+        for templ in templates:
+            if templ.tpe == DeviceType.GeneratorDevice:
+                templ_list.append(templ.name)
+                templ_catalogue[templ.name] = templ
+
+        # prompt RmsModelEditorGUI
+
+        rms_model_editor = RmsModelEditorGUI(api_object_model_host=self.api_object.rms_model, templates_list=templ_list,
+                                             templates_catalogue=templ_catalogue, api_object_name=self.api_object.name,
+                                             api_object=self.api_object, main_editor=True, parent=self.editor)
+        rms_model_editor.show()
+
+    def to_battery(self):
+        """
+        Convert this generator to a battery
+        """
+        ok = yes_no_question('Are you sure that you want to convert this generator into a battery?',
+                             'Convert generator')
+        if ok:
+            self._editor.convert_generator_to_battery(gen=self.api_object, graphic_object=self)
+
+    def enable_disable_control_toggle(self):
+        """
+        Enable / Disable device voltage control
+        """
+        if self.api_object is not None:
+            self.api_object.is_controlled = not self.api_object.is_controlled
+
+    def set_regulation_bus(self):
+        """
+        Set regulation bus
+        :return:
+        """
+        self._editor.set_generator_control_bus(generator_graphics=self)
+
+    def clear_regulation_bus(self):
+        """
+
+        :return:
+        """
+        self.api_object.control_bus = None
+
+    def clear_regulation_cn(self):
+        """
+
+        :return:
+        """
+        self.api_object.control_cn = None
+
+    def edit_q_curve(self):
+        """
+        Open the appropriate editor dialogue
+        :return:
+        """
+        dlg = GeneratorQCurveEditor(q_curve=self.api_object.q_curve,
+                                    Qmin=self.api_object.Qmin,
+                                    Qmax=self.api_object.Qmax,
+                                    Pmin=self.api_object.Pmin,
+                                    Pmax=self.api_object.Pmax,
+                                    Snom=self.api_object.Snom)
+        if dlg.exec():
+            pass
+
+        self.api_object.Snom = np.round(dlg.Snom, 1) if dlg.Snom > 1 else dlg.Snom
+        self.api_object.Qmin = dlg.Qmin
+        self.api_object.Qmax = dlg.Qmax
+        self.api_object.Pmin = dlg.Pmin
+        self.api_object.Pmax = dlg.Pmax
+
+    def solar_pv_wizard(self):
+        """
+        Open the appropriate editor dialogue
+        :return:
+        """
+
+        if self._editor.circuit.has_time_series:
+
+            dlg = SolarPvWizard(time_array=self._editor.circuit.time_profile.strftime("%Y-%m-%d %H:%M").tolist(),
+                                peak_power=self.api_object.Pmax,
+                                latitude=self.api_object.bus.latitude,
+                                longitude=self.api_object.bus.longitude,
+                                gen_name=self.api_object.name,
+                                bus_name=self.api_object.bus.name)
+            if dlg.exec():
+                if dlg.is_accepted:
+                    if len(dlg.P) == self.api_object.P_prof.size():
+                        self.api_object.P_prof.set(dlg.P)
+
+                        self.plot()
+                    else:
+                        raise Exception("Wrong length from the solar photovoltaic wizard")
+        else:
+            info_msg("You need to have time profiles for this function")
+
+    def wind_farm_wizard(self):
+        """
+        Open the appropriate editor dialogue
+        :return:
+        """
+
+        if self._editor.circuit.has_time_series:
+
+            dlg = WindFarmWizard(time_array=self._editor.circuit.time_profile.strftime("%Y-%m-%d %H:%M").tolist(),
+                                 peak_power=self.api_object.Pmax,
+                                 latitude=self.api_object.bus.latitude,
+                                 longitude=self.api_object.bus.longitude,
+                                 gen_name=self.api_object.name,
+                                 bus_name=self.api_object.bus.name)
+            if dlg.exec():
+                if dlg.is_accepted:
+                    if len(dlg.P) == self.api_object.P_prof.size():
+                        self.api_object.P_prof.set(dlg.P)
+                        self.plot()
+                    else:
+                        raise Exception("Wrong length from the solar photovoltaic wizard")
+        else:
+            info_msg("You need to have time profiles for this function")

veragrid-5.6.2/VeraGrid/Gui/Diagrams/MapWidget/Injections/map_injections_template_graphics.py

@@ -0,0 +1,234 @@
+# 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 https://mozilla.org/MPL/2.0/.  
+# SPDX-License-Identifier: MPL-2.0
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, List, Union
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QPen, QCursor, QColor, QBrush
+from PySide6.QtWidgets import (QGraphicsEllipseItem, QMenu,
+                               QGraphicsSceneContextMenuEvent,
+                               QGraphicsSceneMouseEvent)
+from VeraGrid.Gui.gui_functions import add_menu_entry
+from VeraGrid.Gui.Diagrams.MapWidget.Substation.node_template import NodeTemplate
+
+from VeraGridEngine.Devices.types import INJECTION_DEVICE_TYPES
+
+if TYPE_CHECKING:  # Only imports the below statements during type checking
+    from VeraGrid.Gui.Diagrams.MapWidget.grid_map_widget import GridMapWidget
+
+
+class MapInjectionTemplateGraphicItem(NodeTemplate, QGraphicsEllipseItem):
+    """
+    InjectionTemplateGraphicItem
+    """
+
+    def __init__(self,
+                 api_object: INJECTION_DEVICE_TYPES,
+                 editor: GridMapWidget,
+                 lat: float,
+                 lon: float,
+                 size: float = 0.8,
+                 draw_labels: bool = True):
+        """
+
+        :param api_object:
+        :param editor:
+        :param lat:
+        :param lon:
+        :param size:
+        :param draw_labels:
+        """
+        # Correct way to call multiple inheritance
+        super().__init__()
+
+        # Explicitly call QGraphicsRectItem initialization
+        QGraphicsEllipseItem.__init__(self)
+
+        # Explicitly call NodeTemplate initialization
+        NodeTemplate.__init__(self,
+                              api_object=api_object,
+                              editor=editor,
+                              draw_labels=draw_labels,
+                              lat=lat,
+                              lon=lon)
+
+        r2 = size / 2.0
+        x, y = editor.to_x_y(lat=lat, lon=lon)  # upper left corner
+        self.size = size
+        self.setRect(x - r2, y - r2, self.size, self.size)
+
+        # Properties of the container:
+        self.setFlags(self.GraphicsItemFlag.ItemIsSelectable | self.GraphicsItemFlag.ItemIsMovable)
+        self.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+
+        self.set_api_object_color()
+
+    @property
+    def api_object(self) -> INJECTION_DEVICE_TYPES:
+        """
+
+        :return:
+        """
+        return self._api_object
+
+    @property
+    def editor(self) -> GridMapWidget:
+        """
+
+        :return:
+        """
+        return self._editor
+
+    def set_api_object_color(self) -> QColor:
+        """
+        Sets whatever colour is in the API object property
+        """
+
+        color = QColor(self.api_object.color)
+        color.setAlpha(128)
+        self.color = color
+
+        brush = QBrush(color)
+        self.setBrush(brush)
+
+        pen = self.pen()
+        pen.setColor(color)
+        pen.setWidth(0)  # set the pen width to 0
+        self.setPen(pen)
+
+        return color
+
+    def update_position_at_the_diagram(self) -> None:
+        """
+        Updates the element position in the diagram (to save)
+        :return:
+        """
+        lat, long = self.editor.to_lat_lon(self.rect().x(), self.rect().y())
+
+        self.lat = lat
+        self.lon = long
+
+        self.editor.update_diagram_element(device=self.api_object,
+                                           latitude=lat,
+                                           longitude=long,
+                                           graphic_object=self)
+
+    def set_size(self, r: float):
+        """
+
+        :param r: radius in pixels
+        :return:
+        """
+        if r != self.size:
+            rect = self.rect()
+            rect.setWidth(r)
+            rect.setHeight(r)
+
+            # change the width and height while keeping the same center
+            r2 = (self.size - r) / 2
+            new_x = rect.x() + r2
+            new_y = rect.y() + r2
+
+            self.size = r
+
+            # Set the new rectangle with the updated dimensions
+            self.setRect(new_x, new_y, r, r)
+
+    def recolour_mode(self):
+        """
+        Change the colour according to the system theme
+        """
+        super().recolour_mode()
+
+        return self.set_api_object_color()
+
+    def delete(self):
+        """
+        Remove this element
+        @return:
+        """
+
+        deleted, delete_from_db_final = self.editor.delete_with_dialogue(selected=[self], delete_from_db=False)
+
+    def plot(self):
+        """
+        Plot API objects profiles
+        """
+        # time series object from the last simulation
+        ts = self.editor.circuit.time_profile
+
+        # plot the profiles
+        self.api_object.plot_profiles(time=ts)
+
+    def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
+        """
+        mouse press: display the editor
+        :param event:
+        :return:
+        """
+        super().mousePressEvent(event)
+        self._editor.set_editor_model(api_object=self.api_object)
+
+    def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent):
+        """
+        Event handler for mouse release events.
+        """
+        super().mouseReleaseEvent(event)
+        # self.editor.disableMove = True
+        self.update_position_at_the_diagram()  # always update
+
+    def mouseDoubleClickEvent(self, event, /):
+        """
+
+        :param event:
+        :return:
+        """
+        super().mouseDoubleClickEvent(event)
+        self.set_api_object_color()
+
+    def get_base_context_menu(self) -> QMenu:
+        """
+        Generate the base menu for injections
+        :return:
+        """
+        menu = QMenu()
+
+        add_menu_entry(menu=menu,
+                       text="Plot profiles",
+                       function_ptr=self.plot,
+                       icon_path=":/Icons/icons/plot.png")
+
+        add_menu_entry(menu=menu,
+                       text="Consolidate coordinates",
+                       function_ptr=self.consolidate_coordinates,
+                       icon_path=":/Icons/icons/delete_schematic.png")
+
+        menu.addSeparator()
+
+        add_menu_entry(menu=menu,
+                       text="Delete",
+                       function_ptr=self.delete,
+                       icon_path=":/Icons/icons/delete_schematic.png")
+
+        return menu
+
+    def contextMenuEvent(self, event: QGraphicsSceneContextMenuEvent):
+        """
+        Display context menu
+        @param event:
+        @return:
+        """
+        menu = self.get_base_context_menu()
+
+        menu.exec(event.screenPos())
+
+    def consolidate_coordinates(self):
+        """
+        Consolidate coordinates in to the DB
+        """
+        lat, long = self.editor.to_lat_lon(self.rect().x(), self.rect().y())
+        self.api_object.latitude = lat
+        self.api_object.longitude = long
+        self.editor.gui.show_info_toast("Coordinates consolidated!")

veragrid-5.6.2/VeraGrid/Gui/Diagrams/MapWidget/Injections/map_load_graphics.py

@@ -0,0 +1,87 @@
+# 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 https://mozilla.org/MPL/2.0/.  
+# SPDX-License-Identifier: MPL-2.0
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from PySide6 import QtWidgets
+from PySide6.QtCore import QPointF
+from PySide6.QtGui import QPolygonF
+from VeraGrid.Gui.gui_functions import add_menu_entry
+from VeraGrid.Gui.Diagrams.generic_graphics import Polygon
+from VeraGrid.Gui.Diagrams.MapWidget.Injections.map_injections_template_graphics import MapInjectionTemplateGraphicItem
+from VeraGrid.Gui.RmsModelEditor.rms_model_editor_engine import RmsModelEditorGUI
+from VeraGridEngine.Devices.Injections.load import Load
+from VeraGridEngine.enumerations import DeviceType
+
+if TYPE_CHECKING:  # Only imports the below statements during type checking
+    from VeraGrid.Gui.Diagrams.MapWidget.grid_map_widget import GridMapWidget
+
+
+class MapLoadGraphicItem(MapInjectionTemplateGraphicItem):
+
+    def __init__(self, api_object: Load,
+                 editor: GridMapWidget,
+                 lat: float,
+                 lon: float,
+                 size: float = 0.8,
+                 draw_labels: bool = True):
+        """
+
+        :param api_object:
+        :param editor:
+        """
+        MapInjectionTemplateGraphicItem.__init__(self,
+                                                 api_object=api_object,
+                                                 editor=editor,
+                                                 lat=lat,
+                                                 lon=lon,
+                                                 size=size,
+                                                 draw_labels=draw_labels)
+
+    @property
+    def api_object(self) -> Load:
+        return self._api_object
+
+    def contextMenuEvent(self, event: QtWidgets.QGraphicsSceneContextMenuEvent):
+        """
+        Display context menu
+        @param event:
+        @return:
+        """
+        if self.api_object is not None:
+            menu = self.get_base_context_menu()
+            menu.addSection("Load")
+
+            add_menu_entry(menu=menu,
+                           text="Rms Editor",
+                           function_ptr=self.edit_rms,
+                           icon_path=":/Icons/icons/edit.png")
+
+            menu.exec(event.screenPos())
+        else:
+            self.editor.gui.show_error_toast("The graphic has no API object!")
+
+    def edit_rms(self):
+        """
+
+        :return:
+        """
+        # load templates
+        templates = self.editor.circuit.rms_models
+
+        # select line templates
+        templ_catalogue = dict()
+        templ_list = []
+        for templ in templates:
+            if templ.tpe == DeviceType.LoadDevice:
+                templ_list.append(templ.name)
+                templ_catalogue[templ.name] = templ
+
+        # prompt RmsModelEditorGUI
+        rms_model_editor = RmsModelEditorGUI(api_object_model_host=self.api_object.rms_model, templates_list=templ_list,
+                                             templates_catalogue=templ_catalogue, api_object_name=self.api_object.name,
+                                             api_object=self.api_object, main_editor= True, parent=self.editor)
+        rms_model_editor.show()