VeraGridEngine 5.4.11__tar.gz → 5.5.1__tar.gz

{veragridengine-5.4.11 → veragridengine-5.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.4.11
+Version: 5.5.1
 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.

{veragridengine-5.4.11 → veragridengine-5.5.1}/VeraGridEngine/Compilers/circuit_to_gslv.py

@@ -25,7 +25,6 @@ from VeraGridEngine.enumerations import TapModuleControl, TapPhaseControl
 from VeraGridEngine.enumerations import SolverType
 from VeraGridEngine.DataStructures.numerical_circuit import NumericalCircuit
 
-
 from VeraGridEngine.basic_structures import Logger
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
@@ -36,7 +35,6 @@ if TYPE_CHECKING:  # Only imports the below statements during type checking
     from VeraGridEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
 
 
-
 def get_gslv_mip_solvers_list() -> List[str]:
     """
     Get list of available MIP solvers
@@ -2498,6 +2496,37 @@ def gslv_contingencies(circuit: MultiCircuit,
     return res
 
 
+def gslv_linear_matrices(circuit: MultiCircuit,
+                         distributed_slack=False,
+                         correctValues=False,
+                         override_branch_controls=False) -> "pg.LinearAnalysis":
+    """
+    Newton linear analysis
+    :param circuit: MultiCircuit instance
+    :param distributed_slack: distribute the PTDF slack
+    :param correctValues: Correct nonsense values (outsie -1, 1) interval
+    :param override_branch_controls: Override branch controls
+    :return: Newton LinearAnalysisMatrices object
+    """
+    gslv_circuit, _ = to_gslv(circuit=circuit,
+                              use_time_series=False,
+                              override_branch_controls=override_branch_controls)
+
+    options = pg.LinearAnalysisOptions(distributeSlack=distributed_slack,
+                                       correctValues=correctValues,
+                                       ptdfThreshold=0.001,
+                                       lodfThreshold=0.001)
+
+    logger = pg.Logger()
+    nc = pg.compile(grid=gslv_circuit, logger=logger, t_idx=0)
+
+    results = pg.LinearAnalysis(nc=nc,
+                                distributed_slack_=distributed_slack,
+                                correct_values_=correctValues, )
+
+    return results
+
+
 def CheckArr(arr: Vec, arr_expected: Vec, tol: float, name: str, test: str, verbose=False):
     """
 

{veragridengine-5.4.11 → veragridengine-5.5.1}/VeraGridEngine/Compilers/circuit_to_newton_pa.py

@@ -1316,7 +1316,7 @@ def newton_pa_contingencies(circuit: MultiCircuit,
         time_indices = [0]
         n_threads = 0
 
-    if con_opt.contingency_method == ContingencyMethod.PTDF:
+    if con_opt.contingency_method == ContingencyMethod.Linear:
         mode = npa.ContingencyAnalysisMode.Linear
     elif con_opt.contingency_method == ContingencyMethod.PowerFlow:
         mode = npa.ContingencyAnalysisMode.Full

{veragridengine-5.4.11 → veragridengine-5.5.1}/VeraGridEngine/DataStructures/passive_branch_data.py

@@ -145,6 +145,11 @@ class PassiveBranchData(BranchParentData):
         data.virtual_tap_f = self.virtual_tap_f.copy()
         data.virtual_tap_t = self.virtual_tap_t.copy()
 
+        data.Yff3 = self.Yff3.copy()
+        data.Yft3 = self.Yft3.copy()
+        data.Ytt3 = self.Ytt3.copy()
+        data.Ytf3 = self.Ytf3.copy()
+
         data.phA = self.phA.copy()
         data.phB = self.phB.copy()
         data.phC = self.phC.copy()

{veragridengine-5.4.11 → veragridengine-5.5.1}/VeraGridEngine/Devices/Aggregation/__init__.py

@@ -19,3 +19,5 @@ from VeraGridEngine.Devices.Aggregation.branch_group import BranchGroup
 from VeraGridEngine.Devices.Aggregation.modelling_authority import ModellingAuthority
 from VeraGridEngine.Devices.Aggregation.inter_aggregation_info import InterAggregationInfo
 from VeraGridEngine.Devices.Aggregation.facility import Facility
+from VeraGridEngine.Devices.Aggregation.rms_event import RmsEvent
+from VeraGridEngine.Devices.Aggregation.rms_events_group import RmsEventsGroup

veragridengine-5.5.1/VeraGridEngine/Devices/Aggregation/rms_event.py

@@ -0,0 +1,93 @@
+# 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 typing import Union
+import numpy as np
+
+from VeraGridEngine.Devices.Parents.editable_device import EditableDevice
+from VeraGridEngine.Devices.Parents.pointer_device_parent import PointerDeviceParent
+from VeraGridEngine.Devices.Aggregation.rms_events_group import RmsEventsGroup
+from VeraGridEngine.enumerations import DeviceType
+
+
+class RmsEvent(PointerDeviceParent):
+    """
+    Investment
+    """
+    __slots__ = (
+        'parameter',
+        'times',
+        'values',
+        '_group'
+    )
+
+    def __init__(self,
+                 device: EditableDevice | None = None,
+                 parameter: str = None,
+                 times: np.ndarray = None,
+                 values: np.ndarray = None,
+                 idtag: Union[str, None] = None,
+                 name="RmsEvent",
+                 code='',
+                 group: RmsEventsGroup = None,
+                 comment: str = ""):
+        """
+        Investment
+        :param device: Some device to point at
+        :param idtag: String. Element unique identifier
+        :param name: String. Contingency name
+        :param code: String. Contingency code name
+        :param group: RmsEventsGroup. RmsEvent group
+        :param parameter: parameter
+        :param times: time
+        :param values: value
+        :param comment: Comment
+        """
+
+        PointerDeviceParent.__init__(self,
+                                     idtag=idtag,
+                                     device=device,
+                                     code=code,
+                                     name=name,
+                                     device_type=DeviceType.RmsEventDevice,
+                                     comment=comment)
+
+        self._group: RmsEventsGroup = group
+        self.parameter: str = parameter
+        self.times: np.ndarray = times
+        self.values: np.ndarray = values
+
+        self.register(key='parameter', units='', tpe=str,
+                      definition='parameter that the event changes')
+        self.register(key='times', units='', tpe=float,
+                      definition='Time when the event occurs')
+        self.register(key='values', units='', tpe=float,
+                      definition='New value for the parameter')
+        self.register(key='group', units='', tpe=DeviceType.RmsEventsGroupDevice, definition='RmsEvent group')
+
+    @property
+    def group(self) -> RmsEventsGroup:
+        """
+        Group of investments
+        :return:
+        """
+        return self._group
+
+    @group.setter
+    def group(self, val: RmsEventsGroup):
+        self._group = val
+
+    @property
+    def category(self):
+        """
+        Display the group category
+        :return:
+        """
+        return self.group.category
+
+    @category.setter
+    def category(self, val):
+        # The category is set through the group, so no implementation here
+        pass

veragridengine-5.5.1/VeraGridEngine/Devices/Aggregation/rms_events_group.py

@@ -0,0 +1,58 @@
+# 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 typing import Union
+from VeraGridEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+
+
+class RmsEventsGroup(EditableDevice):
+    """
+    Investments group
+    """
+    __slots__ = (
+        'category',
+        'parameter',
+        'time',
+        'value',
+    )
+
+    def __init__(self,
+                 idtag: Union[str, None] = None,
+                 name: str ="RmsEventsGroup",
+                 category: str = '',
+                 parameter: str = None,
+                 time: float = 0.0,
+                 value: float = 0.0,
+                 comment: str = ""):
+        """
+        Contingency group
+        :param idtag: Unique identifier
+        :param name: contingency group name
+        :param category: tag to category the group
+        :param comment: comment
+        :param discount_rate: discount rate (%)
+        :param CAPEX: Capital Expenditure of the group (added to the individual investments' capex)
+        """
+
+        EditableDevice.__init__(self,
+                                name=name,
+                                idtag=idtag,
+                                code='',
+                                device_type=DeviceType.RmsEventsGroupDevice,
+                                comment=comment)
+
+        # Contingency type
+        self.category = category
+        self.parameter: str = parameter
+        self.time: float = time
+        self.value: float = value
+
+        self.register(key='category', units='', tpe=str, definition='Some tag to category the RmsEvent group')
+        self.register(key='parameter', units='', tpe=str,
+                      definition='parameter that the event changes')
+        self.register(key='time', units='', tpe=float,
+                      definition='Time when the event occurs')
+        self.register(key='value', units='', tpe=float,
+                      definition='New value for the parameter')

{veragridengine-5.4.11 → veragridengine-5.5.1}/VeraGridEngine/Devices/Branches/line.py

@@ -714,10 +714,10 @@ class Line(BranchParent):
 
     def initialize_rms(self):
         if self.rms_model.empty():
-            Qf = Var("Qf")
-            Qt = Var("Qt")
-            Pf = Var("Pf")
-            Pt = Var("Pt")
+            Qf = Var("Qf" + self.name)
+            Qt = Var("Qt" + self.name)
+            Pf = Var("Pf" + self.name)
+            Pt = Var("Pt" + self.name)
 
             ys = 1.0 / complex(self.R, self.X)
             g = Const(ys.real)

{veragridengine-5.4.11 → veragridengine-5.5.1}/VeraGridEngine/Devices/Branches/transformer.py

@@ -796,10 +796,10 @@ class Transformer2W(ControllableBranchParent):
     def initialize_rms(self):
         # NOTE: accurate model considering phase shift and tap change still need to be implemented!
         if self.rms_model.empty():
-            Qf = Var("Qf")
-            Qt = Var("Qt")
-            Pf = Var("Pf")
-            Pt = Var("Pt")
+            Qf = Var("Qf" + self.name)
+            Qt = Var("Qt" + self.name)
+            Pf = Var("Pf" + self.name)
+            Pt = Var("Pt" + self.name)
 
             ys = 1.0 / complex(self.R, self.X)
             g = Const(ys.real)

veragridengine-5.5.1/VeraGridEngine/Devices/Diagrams/block_diagram.py

@@ -0,0 +1,9 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+
+
+
+
+

veragridengine-5.5.1/VeraGridEngine/Devices/Dynamic/dynamic_model_host.py

@@ -0,0 +1,292 @@
+# 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 List, Dict, Any, Union
+from dataclasses import dataclass
+from VeraGridEngine.Devices.Parents.editable_device import EditableDevice
+from VeraGridEngine.Utils.Symbolic.block import Block
+from VeraGridEngine.Devices.Dynamic.rms_template import RmsModelTemplate
+from VeraGridEngine.enumerations import DeviceType
+
+
+@dataclass
+
+class BlockDiagramNode:
+    x: float
+    y: float
+    tpe: str
+    device_uid: int
+    sub_diagram: "BlockDiagram" = None
+
+    def get_node_dict(self) -> Dict[str, Any]:
+        data: Dict[str, Any] = {
+            'x': self.x,
+            'y': self.y,
+            'tpe': self.tpe,
+            'device_uid': self.device_uid,
+        }
+        if self.sub_diagram is not None:
+            data['sub_diagram'] = {
+                "nodes": self.sub_diagram.get_node_data_dict(),
+                "connections": self.sub_diagram.get_con_data_dict(),
+            }
+        return data
+
+
+
+
+@dataclass
+class BlockDiagramConnection:
+    from_uid: int
+    to_uid: int
+    port_number_from: int
+    port_number_to: int
+    color: str
+
+    def get_connection_dict(self):
+        """
+        get as a dictionary point
+        :return:
+        """
+        return {'from_uid': self.from_uid,
+                'to_uid': self.to_uid,
+                'port_number_from': self.port_number_from,
+                'port_number_to': self.port_number_to,
+                'color': self.color}
+
+
+
+
+class BlockDiagram:
+    """
+    Diagram
+    """
+
+    def __init__(self, idtag=None, name=''):
+        """
+
+        :param name: Diagram name
+        """
+        self.node_data: Dict[int, BlockDiagramNode] = dict()
+        self.con_data: List[BlockDiagramConnection] = list()
+
+    def add_node(self, x: float, y: float, tpe: str,  device_uid: int, subdiagram: BlockDiagram = None):
+        """
+
+        :param x:
+        :param y:
+        :param device_uid:
+        :param tpe:
+        :param subdiagram:
+        :return:
+        """
+        self.node_data[device_uid] = BlockDiagramNode(
+            x=x,
+            y=y,
+            tpe=tpe,
+            device_uid=device_uid,
+            sub_diagram=subdiagram
+        )
+
+    def add_branch(self, device_uid_from: int, device_uid_to: int,
+                   port_number_from: int, port_number_to: int, color: str):
+        """
+
+        :param device_uid_from:
+        :param device_uid_to:
+        :param port_number_from:
+        :param port_number_to:
+        :param color:
+        :return:
+        """
+        self.con_data.append(
+            BlockDiagramConnection(
+                from_uid=device_uid_from,
+                to_uid=device_uid_to,
+                port_number_from=port_number_from,
+                port_number_to=port_number_to,
+                color=color
+            )
+        )
+    def get_node_data_dict(self) -> Dict[int, Dict[str, Any]]:
+        graph_info ={device_uid: node.get_node_dict() for device_uid, node in self.node_data.items()}
+        return graph_info
+
+    def get_con_data_dict(self) -> Dict[int, Dict[str, Any]]:
+        graph_info = {index: connection.get_connection_dict() for index, connection in enumerate(self.con_data)}
+        return graph_info
+
+    def parse_nodes(self, nodes_data) -> None:
+        """
+        Parse node data from dictionary
+        """
+        self.node_data = dict()
+        for uid, node in nodes_data.items():
+            subdiagram = None
+            if "sub_diagram" in node and node["sub_diagram"] is not None:
+                subdiagram = BlockDiagram()
+                subdiagram.parse_nodes(node["sub_diagram"]["nodes"])
+                subdiagram.parse_branches(node["sub_diagram"]["connections"])
+
+            self.node_data[int(uid)] = BlockDiagramNode(
+                x=node['x'],
+                y=node['y'],
+                tpe=node['tpe'],
+                device_uid=node['device_uid'],
+                sub_diagram=subdiagram
+            )
+
+    def parse_branches(self, con_data) -> None:
+        """
+        Parse connection data from dictionary
+        """
+        self.con_data = []
+        for idx, node in con_data.items():
+            self.con_data.append(BlockDiagramConnection(
+                from_uid=node['from_uid'],
+                to_uid=node['to_uid'],
+                port_number_from=node['port_number_from'],
+                port_number_to=node['port_number_to'],
+                color=node['color'],
+            ))
+
+
+class DynamicModelHost(EditableDevice):
+    """
+    This class serves to give flexible access to either a template or a custom model
+    """
+
+    def __init__(self, name=""):
+
+        super().__init__(name=name,
+                         idtag=None,
+                         code="",
+                         device_type=DeviceType.DynamicModelHostDevice)
+
+        self._template: Block | None = None
+
+        # a custom model always exits although it may be empty
+        self._custom_model: Block = Block()
+        self._diagram: BlockDiagram = BlockDiagram()
+
+    @property
+    def template(self):
+        return self._template
+
+    @template.setter
+    def template(self, val: Block | RmsModelTemplate):
+
+        if isinstance(val, RmsModelTemplate):
+            self._template = val.block
+
+        elif isinstance(val, Block):
+            self._template = val
+
+        else:
+            raise ValueError(f"Cannot set template with {val}")
+
+    @property
+    def custom_model(self):
+        return self._custom_model
+
+    @property
+    def model(self) -> Block:
+        """
+        Returns whatever is available with preference to the custom model if any
+        :return: DynamicModel (even if it is empty)
+        """
+        if self.template is None:
+            return self.custom_model
+        else:
+            return self.template
+
+    @model.setter
+    def model(self, val: Block | RmsModelTemplate):
+
+        if isinstance(val, RmsModelTemplate):
+            self.template = val.block
+
+        elif isinstance(val, Block):
+            self._custom_model = val
+
+        else:
+            raise ValueError(f"Cannot set model with {val}")
+
+    @property
+    def diagram(self) -> BlockDiagram:
+
+        return self._diagram
+
+    @diagram.setter
+    def diagram(self, val: BlockDiagram | Dict[str, Any]):
+
+        if isinstance(val, BlockDiagram):
+            self._diagram = val
+        elif isinstance(val, dict):
+            diagram = BlockDiagram()
+            if "nodes" in val:
+                diagram.parse_nodes(val["nodes"])
+            if "connections" in val:
+                diagram.parse_branches(val["connections"])
+            self._diagram = diagram
+        else:
+            raise ValueError(f"Cannot set diagram with {val}")
+
+    def to_dict(self) -> Dict[str, int | Dict[str, List[Dict[str, Any]]]]:
+        """
+        Generate a dictionary to save
+        :return: Data to save
+        """
+        return {
+            "template": self.template.uid if self.template is not None else None,
+            "custom_model": self.custom_model.to_dict()
+        }
+
+    def parse(self, data: Dict[str, str | Dict[str, List[Dict[str, Any]]]],
+              models_dict: Dict[str, RmsModelTemplate]):
+        """
+        Parse the data
+        :param data: data generated by to_dict
+        :param models_dict: dictionary of DynamicModel to find the template reference
+        """
+        template_id = data.get("template", None)
+        if template_id is not None:
+            self.template = models_dict.get(template_id, None)
+
+        custom_data = data.get("custom_model", None)
+        self._custom_model = Block.parse(data=custom_data)
+
+    def empty(self):
+        if self._template is None:
+            return self._custom_model.empty()
+        else:
+            return self._template.empty()
+
+    def __eq__(self, other):
+        if isinstance(other, DynamicModelHost):
+
+            if self.template is None:
+                if other.template is None:
+                    return self.custom_model == other.custom_model
+                else:
+                    return False
+            else:
+                if other.template is None:
+                    return False
+                else:
+                    return self.template.uid == other.template.uid
+        else:
+            return False
+
+    def copy(self) -> "DynamicModelHost":
+        """
+        Deep copy of DynamicModelHost
+        :return: DynamicModelHost
+        """
+        obj = DynamicModelHost()
+        obj._custom_model = self._custom_model.copy()
+        obj._template = self._template
+        return obj

{veragridengine-5.4.11 → veragridengine-5.5.1}/VeraGridEngine/Devices/Dynamic/events.py

@@ -12,14 +12,25 @@ import numpy as np
 
 class RmsEvent:
     def __init__(self,
-                 device: str,
-                 variable: Var,
+                 device_type: str,
+                 device_name: str,
+                 variable: str,
                  time_step: int = 0.0,
                  value: float = 0.0):
-        self._device = device
+        self._device_type = device_type
+        self._device_name = device_name
         self._variable = variable
-        self._time_step = time_step
         self._value = value
+        self._time_step = time_step
+
+
+    @property
+    def device_type(self):
+        return self._device_type
+
+    @property
+    def device_name(self):
+        return self._device_name
 
     @property
     def variable(self):

{veragridengine-5.4.11 → veragridengine-5.5.1}/VeraGridEngine/Devices/Dynamic/rms_template.py

@@ -12,16 +12,15 @@ class RmsModelTemplate(EditableDevice):
     """
     This class serves to give flexible access to either a template or a custom model
     """
-    def __init__(self, name: str = ""):
 
+    def __init__(self, name: str = ""):
         super().__init__(name=name,
                          idtag=None,
                          code="",
-                         device_type= DeviceType.RmsModelTemplateDevice)
+                         device_type=DeviceType.RmsModelTemplateDevice)
 
         self._block: Block = Block()
 
     @property
     def block(self):
         return self._block
-