VeraGridEngine 5.4.5__tar.gz → 5.4.7__tar.gz

{veragridengine-5.4.5 → veragridengine-5.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.4.5
+Version: 5.4.7
 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.5 → veragridengine-5.4.7}/VeraGridEngine/Compilers/circuit_to_data.py

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
 import numpy as np
+from cmath import rect
 from typing import Dict, Union, TYPE_CHECKING
 
 from VeraGridEngine.basic_structures import Logger
@@ -100,12 +101,14 @@ def set_bus_control_voltage(i: int,
     if not use_stored_guess:
         if not bus_voltage_used[i]:
             if remote_control and j > -1 and j != i:
-                # initialize the remote bus voltage to the control value
-                bus_data.Vbus[j] = complex(candidate_Vm, 0)
+                # initialize the remote bus voltage to the control value but preserve angle while updating magnitude
+                existing_angle = np.angle(bus_data.Vbus[j])
+                bus_data.Vbus[j] = rect(candidate_Vm, existing_angle)
                 bus_voltage_used[j] = True
             else:
-                # initialize the local bus voltage to the control value
-                bus_data.Vbus[i] = complex(candidate_Vm, 0)
+                # initialize the local bus voltage to the control value but preserve angle while updating magnitude
+                existing_angle = np.angle(bus_data.Vbus[i])
+                bus_data.Vbus[i] = rect(candidate_Vm, existing_angle)
                 bus_voltage_used[i] = True
 
         elif candidate_Vm != bus_data.Vbus[i]:
@@ -158,12 +161,14 @@ def set_bus_control_voltage_vsc(i: int,
     if not use_stored_guess:
         if not bus_voltage_used[i]:
             if remote_control and j > -1 and j != i:
-                # initialize the remote bus voltage to the control value
-                bus_data.Vbus[j] = complex(candidate_Vm, 0)
+                # initialize the remote bus voltage to the control value but preserve angle while updating magnitude
+                existing_angle = np.angle(bus_data.Vbus[j])
+                bus_data.Vbus[j] = complex(candidate_Vm, 0) * np.exp(1j * existing_angle)
                 bus_voltage_used[j] = True
             else:
-                # initialize the local bus voltage to the control value
-                bus_data.Vbus[i] = complex(candidate_Vm, 0)
+                # initialize the local bus voltage to the control value but preserve angle while updating magnitude
+                existing_angle = np.angle(bus_data.Vbus[i])
+                bus_data.Vbus[i] = complex(candidate_Vm, 0) * np.exp(1j * existing_angle)
                 bus_voltage_used[i] = True
 
         elif candidate_Vm != bus_data.Vbus[i]:
@@ -172,6 +177,67 @@ def set_bus_control_voltage_vsc(i: int,
                              value=candidate_Vm,
                              expected_value=bus_data.Vbus[i])
 
+def set_bus_control_angle_vsc(i: int,
+                                j: int,
+                                remote_control: bool,
+                                bus_name: str,
+                                bus_angle_used: BoolVec,
+                                bus_data: BusData,
+                                candidate_Va: float,
+                                use_stored_guess: bool,
+                                logger: Logger) -> None:
+    """
+    Set the bus control angle
+    :param i: Bus index
+    :param j: Remote Bus index
+    :param remote_control: Using remote control?
+    :param bus_name: Bus name
+    :param bus_angle_used: Array of flags indicating if a bus angle has been modified before
+    :param bus_data: BusData
+    :param candidate_Va: Angle set point that you want to set in degrees
+    :param use_stored_guess: Use the stored seed values?
+    :param logger: Logger
+    """
+    if bus_data.bus_types[i] != BusMode.Slack_tpe.value:  # if it is not Slack
+        if remote_control and j > -1 and j != i:
+            # delete angle control
+            # bus_data.bus_types[j] = BusMode.PQV_tpe.value  # remote bus to PQV type
+            # bus_data.set_bus_mode(j, BusMode.PQV_tpe)
+            bus_data.is_p_controlled[j] = True
+            bus_data.is_q_controlled[j] = True
+            bus_data.is_va_controlled[j] = True
+
+            # bus_data.bus_types[i] = BusMode.P_tpe.value  # local bus to P type
+            # bus_data.set_bus_mode(i, BusMode.P_tpe)
+            bus_data.is_p_controlled[i] = True
+        else:
+            # local angle control controlling q as well
+            # bus_data.bus_types[i] = BusMode.PV_tpe.value  # set as PV
+            # bus_data.set_bus_mode(i, BusMode.PV_tpe)
+            bus_data.is_q_controlled[i] = True
+            bus_data.is_va_controlled[i] = True
+
+    if not use_stored_guess:
+        if not bus_angle_used[i]:
+            if remote_control and j > -1 and j != i:
+                # initialize the remote bus angle to the control value but preserve magnitude while updating angle
+                existing_magnitude = np.abs(bus_data.Vbus[j])
+                bus_data.Vbus[j] = existing_magnitude * np.exp(1j * candidate_Va * np.pi / 180)
+                bus_angle_used[j] = True
+
+            else:
+                # initialize the local bus angle to the control value but preserve magnitude while updating angle
+                existing_magnitude = np.abs(bus_data.Vbus[i])
+                bus_data.Vbus[i] = existing_magnitude * np.exp(1j * candidate_Va * np.pi / 180)
+                bus_angle_used[i] = True
+
+        else:
+            existing_angle = np.angle(bus_data.Vbus[i])
+            if not np.isclose(candidate_Va, existing_angle):
+                logger.add_error(msg='Different control angle set points',
+                                 device=bus_name,
+                                 value=candidate_Va,
+                                 expected_value=existing_angle)
 
 def set_bus_control_voltage_hvdc(i: int,
                                  j: int,
@@ -1757,6 +1823,7 @@ def set_control_dev(k: int,
                     bus_dict: Dict[Bus, int],
                     bus_data: BusData,
                     bus_voltage_used: BoolVec,
+                    bus_angle_used: BoolVec,
                     use_stored_guess: bool,
                     logger: Logger):
     """
@@ -1772,6 +1839,7 @@ def set_control_dev(k: int,
     :param bus_dict: dictionary to be filled in
     :param bus_data: bus data
     :param bus_voltage_used: used bus voltage
+    :param bus_angle_used: used bus angle
     :param use_stored_guess:
     :param logger:
     """
@@ -1806,6 +1874,17 @@ def set_control_dev(k: int,
                                             use_stored_guess=use_stored_guess,
                                             logger=logger)
 
+            elif control == ConverterControlType.Va_ac:
+                set_bus_control_angle_vsc(i=bus_idx,
+                                            j=-1,
+                                            remote_control=False,
+                                            bus_name=str(bus_data.names[bus_idx]),
+                                            bus_angle_used=bus_angle_used,
+                                            bus_data=bus_data,
+                                            candidate_Va=control_val,
+                                            use_stored_guess=use_stored_guess,
+                                            logger=logger)
+
         else:
             # TODO: the formulation does not allow for VSC remote control yet
             # control_branch_idx[k] = branch_dict[control_dev]
@@ -1837,6 +1916,18 @@ def set_control_dev(k: int,
                                         candidate_Vm=control_val,
                                         use_stored_guess=use_stored_guess,
                                         logger=logger)
+        elif control == ConverterControlType.Va_ac:
+            control_bus_idx[k] = t
+
+            set_bus_control_angle_vsc(i=t,
+                                      j=-1,
+                                      remote_control=False,
+                                      bus_name=str(bus_data.names[t]),
+                                      bus_angle_used=bus_angle_used,
+                                      bus_data=bus_data,
+                                      candidate_Va=control_val,
+                                      use_stored_guess=use_stored_guess,
+                                      logger=logger)
 
         else:
             # control_branch_idx[k] = len(branch_dict) + k  # TODO: why?
@@ -1873,7 +1964,7 @@ def get_vsc_data(
     :param logger: Logger
     :return: VscData
     """
-
+    bus_angle_used = bus_data.bus_types == BusMode.Slack_tpe.value
     ii = 0
 
     # VSC
@@ -1914,6 +2005,7 @@ def get_vsc_data(
                             bus_dict=bus_dict,
                             bus_data=bus_data,
                             bus_voltage_used=bus_voltage_used,
+                            bus_angle_used=bus_angle_used,
                             use_stored_guess=use_stored_guess,
                             logger=logger)
             set_control_dev(k=ii, f=f, t=t,
@@ -1925,6 +2017,7 @@ def get_vsc_data(
                             bus_dict=bus_dict,
                             bus_data=bus_data,
                             bus_voltage_used=bus_voltage_used,
+                            bus_angle_used=bus_angle_used,
                             use_stored_guess=use_stored_guess,
                             logger=logger)
 
@@ -1949,6 +2042,7 @@ def get_vsc_data(
                             bus_dict=bus_dict,
                             bus_data=bus_data,
                             bus_voltage_used=bus_voltage_used,
+                            bus_angle_used=bus_angle_used,
                             use_stored_guess=use_stored_guess,
                             logger=logger)
 
@@ -1961,6 +2055,7 @@ def get_vsc_data(
                             bus_dict=bus_dict,
                             bus_data=bus_data,
                             bus_voltage_used=bus_voltage_used,
+                            bus_angle_used=bus_angle_used,
                             use_stored_guess=use_stored_guess,
                             logger=logger)
 

{veragridengine-5.4.5 → veragridengine-5.4.7}/VeraGridEngine/Devices/Branches/vsc.py

@@ -156,9 +156,31 @@ class VSC(BranchParent):
         #     self._bus_dc_n = None
         #     self._bus_to = None
 
-        self._bus_from = bus_from
+        # the VSC must only connect from an DC to a AC bus
+        # this connectivity sense is done to keep track with the articles that set it
+        # from -> DC
+        # to   -> AC
+        # assert(bus_from.is_dc != bus_to.is_dc)
+        if bus_to is not None and bus_from is not None:
+            # connectivity:
+            # for the later primitives to make sense, the "bus from" must be AC and the "bus to" must be DC
+            if bus_from.is_dc and not bus_to.is_dc:  # this is the correct sense
+                self.bus_from = bus_from
+                self.bus_to = bus_to
+            elif not bus_from.is_dc and bus_to.is_dc:  # opposite sense, revert
+                self.bus_from = bus_to
+                self.bus_to = bus_from
+                print('Corrected the connection direction of the VSC device:', self.name)
+            else:
+                raise Exception('Impossible connecting a VSC device here. '
+                                'VSC devices must be connected between AC and DC buses')
+        else:
+            self.bus_from = None
+            self.bus_to = None
+
+        # self._bus_from = bus_from
         self._bus_dc_n = bus_dc_n
-        self._bus_to = bus_to
+        # self._bus_to = bus_to
 
         self.kdp = float(kdp)
         self.alpha1 = float(alpha1)

{veragridengine-5.4.5 → veragridengine-5.4.7}/VeraGridEngine/Devices/Diagrams/base_diagram.py

@@ -449,10 +449,7 @@ class BaseDiagram:
         # Add the electrical branches ----------------------------------------------------------------------------------
         tuples = list()
         for dev_type in [DeviceType.LineDevice,
-                         DeviceType.DCLineDevice,
-                         DeviceType.HVDCLineDevice,
                          DeviceType.Transformer2WDevice,
-                         DeviceType.VscDevice,
                          DeviceType.UpfcDevice]:
 
             groups = self.data.get(dev_type.value, None)
@@ -471,6 +468,62 @@ class BaseDiagram:
 
                         tuples.append((f, t, w))
 
+        for dev_type in [DeviceType.DCLineDevice]:
+
+            groups = self.data.get(dev_type.value, None)
+
+            if groups:
+                for i, (idtag, location) in enumerate(groups.locations.items()):
+                    branch = location.api_object
+                    f = graph_node_dictionary.get(branch.bus_from.idtag, None)
+                    t = graph_node_dictionary.get(branch.bus_to.idtag, None)
+
+                    if f is not None and t is not None:
+                        w = branch.R
+                        tuples.append((f, t, w))
+
+        for dev_type in [DeviceType.HVDCLineDevice]:
+
+            groups = self.data.get(dev_type.value, None)
+
+            if groups:
+                for i, (idtag, location) in enumerate(groups.locations.items()):
+                    branch = location.api_object
+                    f = graph_node_dictionary.get(branch.bus_from.idtag, None)
+                    t = graph_node_dictionary.get(branch.bus_to.idtag, None)
+
+                    if f is not None and t is not None:
+                        w = max(branch.r, 0.01)
+                        tuples.append((f, t, w))
+
+        for dev_type in [DeviceType.VscDevice]:
+
+            groups = self.data.get(dev_type.value, None)
+
+            if groups:
+                for i, (idtag, location) in enumerate(groups.locations.items()):
+                    branch = location.api_object
+                    f = graph_node_dictionary.get(branch.bus_from.idtag, None)
+                    t = graph_node_dictionary.get(branch.bus_to.idtag, None)
+
+                    if f is not None and t is not None:
+                        w = 0.01
+                        tuples.append((f, t, w))
+
+        for dev_type in [DeviceType.SwitchDevice]:
+
+            groups = self.data.get(dev_type.value, None)
+
+            if groups:
+                for i, (idtag, location) in enumerate(groups.locations.items()):
+                    branch = location.api_object
+                    f = graph_node_dictionary.get(branch.bus_from.idtag, None)
+                    t = graph_node_dictionary.get(branch.bus_to.idtag, None)
+
+                    if f is not None and t is not None:
+                        w = max(branch.R, 0.001)
+                        tuples.append((f, t, w))
+
         # Add fluid branches -------------------------------------------------------------------------------------------
         for dev_type in [DeviceType.FluidPathDevice]:
 

{veragridengine-5.4.5 → veragridengine-5.4.7}/VeraGridEngine/Devices/assets.py

@@ -1707,6 +1707,18 @@ class Assets:
             gen_index_dict[elm.idtag] = k  # associate the idtag to the index
         return gen_index_dict
 
+    def get_generator_bus_index_dict(self, bus_index_dict: Dict[dev.Bus, int] = None):
+        """
+        Get a dictionary of generators related to their bus index
+        :param bus_index_dict: bus object to bus index dictionary (optional)
+        :return: generator object to bus index dictionary
+
+        """
+        if bus_index_dict is None:
+            bus_index_dict = self.get_bus_index_dict()
+
+        return {g.idtag: bus_index_dict[g.bus] for g in self.get_generators() if g.bus is not None}
+
     # ------------------------------------------------------------------------------------------------------------------
     # External grid
     # ------------------------------------------------------------------------------------------------------------------

{veragridengine-5.4.5 → veragridengine-5.4.7}/VeraGridEngine/Devices/multi_circuit.py

@@ -23,7 +23,7 @@ import VeraGridEngine.Devices as dev
 from VeraGridEngine.Devices.types import ALL_DEV_TYPES, INJECTION_DEVICE_TYPES, FLUID_TYPES, AREA_TYPES
 from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Topology.topology import find_different_states
-from VeraGridEngine.enumerations import DeviceType, ActionType, SubObjectType, DynamicVarType
+from VeraGridEngine.enumerations import DeviceType, ActionType, SubObjectType, ConverterControlType
 
 
 if TYPE_CHECKING:
@@ -656,6 +656,74 @@ class MultiCircuit(Assets):
 
         return line
 
+    def convert_hvdc_line_to_vsc_system(self, hvdc_line: dev.HvdcLine):
+        """
+        Convert a HvdcLine to the corresponding VSC-DcLine-VSC system
+        :param hvdc_line: HvdcLine
+        :return: ac_bus_1, ac_bus_2, dc_bus_1, dc_bus_2, conv1, conv2, dc_line
+        """
+        ac_bus_1 = hvdc_line.bus_from
+        ac_bus_2 = hvdc_line.bus_to
+
+        dc_bus_1 = dev.Bus(name=ac_bus_1.name + " DC",
+                           Vnom=hvdc_line.dc_link_voltage,
+                           is_dc=True,
+                           latitude=ac_bus_1.latitude,
+                           longitude=ac_bus_1.longitude,
+                           area=ac_bus_1.area,
+                           zone=ac_bus_1.zone,
+                           substation=ac_bus_1.substation,
+                           voltage_level=ac_bus_1.voltage_level,
+                           country=ac_bus_1.country)
+
+        dc_bus_2 = dev.Bus(name=ac_bus_2.name + " DC",
+                           Vnom=hvdc_line.dc_link_voltage,
+                           is_dc=True,
+                           latitude=ac_bus_2.latitude,
+                           longitude=ac_bus_2.longitude,
+                           area=ac_bus_2.area,
+                           zone=ac_bus_2.zone,
+                           substation=ac_bus_2.substation,
+                           voltage_level=ac_bus_2.voltage_level,
+                           country=ac_bus_2.country)
+
+        conv1 = dev.VSC(name=hvdc_line.name + " converter from",
+                        bus_from=dc_bus_1,
+                        bus_to=ac_bus_1,
+                        rate=hvdc_line.rate,
+                        control1=ConverterControlType.Pdc,
+                        control2=ConverterControlType.Vm_ac,
+                        control1_val=hvdc_line.Pset,
+                        control2_val=hvdc_line.Vset_f)
+
+        conv2 = dev.VSC(name=hvdc_line.name + " converter to",
+                        bus_from=dc_bus_2,
+                        bus_to=ac_bus_2,
+                        rate=hvdc_line.rate,
+                        control1=ConverterControlType.Vm_dc,
+                        control2=ConverterControlType.Vm_ac,
+                        control1_val=hvdc_line.Vset_t,
+                        control2_val=hvdc_line.Vset_t)
+
+        Ibase = self.Sbase / hvdc_line.dc_link_voltage
+        Zbase = hvdc_line.dc_link_voltage / Ibase
+
+        dc_line = dev.DcLine(name=hvdc_line.name,
+                             bus_from=dc_bus_1,
+                             bus_to=dc_bus_2,
+                             rate=hvdc_line.rate,
+                             r=hvdc_line.r / Zbase)
+
+        self.add_bus(dc_bus_1)
+        self.add_bus(dc_bus_2)
+        self.add_vsc(conv1)
+        self.add_vsc(conv2)
+        self.add_dc_line(dc_line)
+
+        self.delete_hvdc_line(hvdc_line)
+
+        return ac_bus_1, ac_bus_2, dc_bus_1, dc_bus_2, conv1, conv2, dc_line
+
     def plot_graph(self, ax=None):
         """
         Plot the grid.

{veragridengine-5.4.5 → veragridengine-5.4.7}/VeraGridEngine/IO/epc/epc_parser.py

@@ -213,7 +213,7 @@ def parse_buses(data_lst: List[List], substations_dict: Dict[int, dev.Substation
             area = None
 
         if area_dict is not None:
-            zone_idx = raw[9]  # or maybe 28
+            zone_idx = raw[10]  # or maybe 28
             zone = zone_dict[zone_idx]
         else:
             zone = None