VeraGridEngine 5.6.10__tar.gz → 5.6.12__tar.gz

{veragridengine-5.6.10 → veragridengine-5.6.12}/PKG-INFO

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

@@ -1306,7 +1306,7 @@ def fill_controllable_branch(
     ctrl_data.vset[ii] = elm.get_vset_at(t_idx)
 
     if opf_results is not None:
-        ctrl_data.tap_angle[ii] = opf_results.phase_shift[t_idx, ii]
+        ctrl_data.tap_angle[ii] = opf_results.tap_angle[t_idx, ii]
         ctrl_data.tap_module[ii] = elm.get_tap_module_at(t_idx)
     else:
         ctrl_data.tap_angle[ii] = elm.get_tap_phase_at(t_idx)

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Compilers/circuit_to_gslv.py

@@ -2407,7 +2407,7 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults", lo
     results.loading_hvdc = res.loading_hvdc[0, :]
     results.losses_hvdc = res.losses_hvdc[0, :]
 
-    results.Pf_vsc = res.Pf_vsc[0, :]
+    results.Pfp_vsc = res.Pfp_vsc[0, :]
     results.St_vsc = res.St_vsc[0, :]
     results.loading_vsc = res.loading_vsc[0, :]
     results.losses_vsc = res.losses_vsc[0, :]

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Compilers/circuit_to_newton_pa.py

@@ -1568,7 +1568,7 @@ def translate_newton_pa_opf_results(grid: MultiCircuit, res: "npa.NonlinearOpfRe
     results.load_shedding = res.load_shedding[0, :],
     results.hvdc_power = res.hvdc_Pf[0, :],
     results.hvdc_loading = res.hvdc_loading[0, :] * 100.0,
-    results.phase_shift = res.tap_angle[0, :],
+    results.tap_angle = res.tap_angle[0, :],
     results.bus_shadow_prices = res.bus_shadow_prices[0, :],
     results.generator_shedding = res.generator_shedding[0, :],
     results.battery_power = res.battery_p[0, :],

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Devices/Branches/overhead_line_type.py

@@ -9,6 +9,7 @@ from warnings import warn
 import numpy as np
 from numpy import pi, log, sqrt
 from matplotlib import pyplot as plt
+import math
 
 from VeraGridEngine.Devices.admittance_matrix import AdmittanceMatrix
 from VeraGridEngine.basic_structures import Logger, Mat, IntVec, Vec, CxMat
@@ -36,6 +37,16 @@ def phase2circuit(phase: int) -> int:
     k = int((phase - 1) / 3)
     return k + 1
 
+def build_y_4x4(y_nxn: np.ndarray, circuit_idx: int) -> np.ndarray:
+    start = 3 * (circuit_idx - 1) + 1
+    idx = [0, start, start + 1, start + 2]
+    return y_nxn[np.ix_(idx, idx)]
+
+def n_circuits(idx):
+    m = max(idx)
+    if m <= 0:
+        return 0
+    return math.ceil(m / 3)
 
 class WireInTower:
     """
@@ -501,45 +512,30 @@ class OverheadLineType(EditableDevice):
         :return: AdmittanceMatrix with series admittance in p.u.
         """
         Zbase = (Vnom * Vnom) / Sbase
-        rows, columns = self.z_nabc.shape
         adm = AdmittanceMatrix(size=4)
 
-        if rows % 4 == 0 and columns % 4 == 0:
-            k = (4 * (circuit_idx - 1)) + np.array([0, 1, 2, 3])
-            z = self.z_nabc[np.ix_(k, k)] * length / Zbase
-            adm.values = np.linalg.inv(z)
-            adm.phN = 1
-            adm.phA = 1
-            adm.phB = 1
-            adm.phC = 1
-
-            return adm
+        z = self.z_nabc * length / Zbase
+        y = np.linalg.inv(z)
 
-        elif rows < 4 and columns < 4:
-            phases = self.z_phases_nabc
-            phases = phases[phases > 4 * (circuit_idx - 1)]
-            phases = phases[phases <= 4 * circuit_idx]
-            phases = phases - 4 * (circuit_idx - 1)
+        n_c = n_circuits(self.z_phases_nabc)
+        n = 4 * n_c - (n_c - 1)
 
-            z = self.z_nabc * length / Zbase
-            y = np.linalg.inv(z)
-            y_4x4 = np.zeros((4, 4), dtype=complex)
-            y_4x4[np.ix_(phases, phases)] = y
+        y_nxn = np.zeros((n, n), dtype=complex)
+        y_nxn[np.ix_(self.z_phases_nabc, self.z_phases_nabc)] = y
 
-            adm.values = y_4x4
-            if 0 in self.y_phases_nabc:
-                adm.phN = 1
-            if 1 in self.y_phases_nabc:
-                adm.phA = 1
-            if 2 in self.y_phases_nabc:
-                adm.phB = 1
-            if 3 in self.y_phases_nabc:
-                adm.phC = 1
+        y_4x4 = build_y_4x4(y_nxn, circuit_idx)
 
-            return adm
+        adm.values = y_4x4
+        if 0 in self.y_phases_nabc:
+            adm.phN = 1
+        if 1 in self.y_phases_nabc:
+            adm.phA = 1
+        if 2 in self.y_phases_nabc:
+            adm.phB = 1
+        if 3 in self.y_phases_nabc:
+            adm.phC = 1
 
-        else:
-            raise Exception("Invalid overhead line type configuration")
+        return adm
 
     def get_ysh(self, circuit_idx: int, Sbase: float, length: float, Vnom: float) -> AdmittanceMatrix:
         """
@@ -551,45 +547,30 @@ class OverheadLineType(EditableDevice):
         :return: AdmittanceMatrix with shunt admittance in p.u.
         """
 
-        if circuit_idx == 0:
-            circuit_idx = 1
-
         Zbase = (Vnom * Vnom) / Sbase
         Ybase = 1 / Zbase
-
-        rows, columns = self.y_nabc.shape
         adm = AdmittanceMatrix(size=4)
 
-        if rows % 4 == 0 and columns % 4 == 0:
-            k = (4 * (circuit_idx - 1)) + np.array([0, 1, 2, 3])
-            y = self.y_nabc[np.ix_(k, k)] * length * 1e6 / Ybase
-            adm.values = y
+        y = self.y_nabc * length * 1e6 / Ybase
+
+        n_c = n_circuits(self.z_phases_nabc)
+        n = 4 * n_c - (n_c - 1)
+
+        y_nxn = np.zeros((n, n), dtype=complex)
+        y_nxn[np.ix_(self.z_phases_nabc, self.z_phases_nabc)] = y
+
+        y_4x4 = build_y_4x4(y_nxn, circuit_idx)
+
+        adm.values = y_4x4
+        if 0 in self.y_phases_nabc:
             adm.phN = 1
+        if 1 in self.y_phases_nabc:
             adm.phA = 1
+        if 2 in self.y_phases_nabc:
             adm.phB = 1
+        if 3 in self.y_phases_nabc:
             adm.phC = 1
 
-        else:
-            phases = self.y_phases_nabc
-
-            phases = phases[phases > 4 * (circuit_idx - 1)]
-            phases = phases[phases <= 4 * circuit_idx]
-            phases = phases - 4 * (circuit_idx - 1)
-
-            y = self.y_nabc * length * 1e6 / Ybase
-            y_4x4 = np.zeros((4, 4), dtype=complex)
-            y_4x4[np.ix_(phases, phases)] = y
-
-            adm.values = y_4x4
-            if 1 in self.y_phases_nabc:
-                adm.phN = 1
-            if 2 in self.y_phases_nabc:
-                adm.phA = 1
-            if 3 in self.y_phases_nabc:
-                adm.phB = 1
-            if 4 in self.y_phases_nabc:
-                adm.phC = 1
-
         return adm
 
     def add_wire_relationship(self, wire: Wire,

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Devices/Branches/sequence_line_type.py

@@ -194,7 +194,7 @@ class SequenceLineType(EditableDevice):
         except np.linalg.LinAlgError:
             adm.values = np.linalg.pinv(zabc)
 
-        adm.phN = 0
+        adm.phN = 1
         adm.phA = 1
         adm.phB = 1
         adm.phC = 1
@@ -222,9 +222,9 @@ class SequenceLineType(EditableDevice):
         adm = AdmittanceMatrix(size=4)
         adm.values = yabc
 
-        adm.phN = 0
+        adm.phN = 1
         adm.phA = 1
         adm.phB = 1
         adm.phC = 1
 
-        return adm
+        return adm

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Devices/Injections/generator.py

@@ -2,7 +2,7 @@
 # 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
 
 import numpy as np
 import pandas as pd
@@ -343,6 +343,16 @@ class Generator(GeneratorParent):
         """
         return get_at(self.Pf, self.Pf_prof, t)
 
+    def get_Q_at(self, t: int | None) -> float:
+        """
+        :param t:
+        :return:
+        """
+        p = self.get_P_at(t)
+        pf = get_at(self.Pf, self.Pf_prof, t)
+
+        return p * np.sqrt(1.0 / (pf * pf) - 1.0)
+
     @property
     def Vset_prof(self) -> Profile:
         """

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Devices/Injections/static_generator.py

@@ -9,11 +9,11 @@ from VeraGridEngine.Devices.Parents.load_parent import LoadParent
 
 
 class StaticGenerator(LoadParent):
-    __slots__ = ()
+    __slots__ = ("_Snom")
 
     def __init__(self, name='StaticGen', idtag=None, code='', P=0.0, Q=0.0, active=True,
                  P1=0.0, P2=0.0, P3=0.0, Q1=0.0, Q2=0.0, Q3=0.0,
-                 mttf=0.0, mttr=0.0, Cost=1200.0,
+                 mttf=0.0, mttr=0.0, Cost=1200.0, Snom=0,
                  capex=0, opex=0, build_status: BuildStatus = BuildStatus.Commissioned):
         """
 
@@ -58,3 +58,25 @@ class StaticGenerator(LoadParent):
                             opex=opex,
                             build_status=build_status,
                             device_type=DeviceType.StaticGeneratorDevice)
+
+        # Nominal power in MVA (also the machine base)
+        self._Snom = float(Snom)
+
+        self.register(key='Snom', units='MVA', tpe=float, definition='Nominal power.')
+
+    @property
+    def Snom(self):
+        """
+        Return the reactive power lower limit
+        :return: value
+        """
+        return self._Snom
+
+    @Snom.setter
+    def Snom(self, val):
+        """
+        Set the generator nominal power
+        if the reactive power curve was generated automatically, then it is refreshed
+        :param val: float value
+        """
+        self._Snom = val

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Devices/Parents/branch_parent.py

@@ -497,6 +497,18 @@ class BranchParent(PhysicalDevice):
         else:
             return bus_t_v, bus_f_v
 
+    def get_buses_sorted_by_voltage(self):
+        """
+        Get the sorted buses
+        :return: HV bus, LV bus
+        """
+        bus_f_v = self.bus_from.Vnom
+        bus_t_v = self.bus_to.Vnom
+        if bus_f_v > bus_t_v:
+            return self.bus_from, self.bus_to
+        else:
+            return self.bus_to, self.bus_from
+
     def get_virtual_taps(self) -> Tuple[float, float]:
         """
         Get the branch virtual taps

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Devices/Parents/load_parent.py

@@ -370,6 +370,17 @@ class LoadParent(InjectionParent):
         """
         return complex(self.get_Pc_at(t), self.get_Qc_at(t))
 
+    def get_Pf_at(self, t: int | None) -> float:
+        """
+        Get power factor
+        :param t:
+        :return:
+        """
+        p = self.get_P_at(t)
+        q = self.get_Q_at(t)
+        s = np.sqrt(p*p + q*q)
+        return p / s if s > 0.0 else 0.0
+
     def split_sequence_load_in_3_phase(self, share_a=1.0, share_b=1.0, share_c=1.0):
         """
         Initializes the 3-phase properties using the positive sequence ones

{veragridengine-5.6.10 → veragridengine-5.6.12}/VeraGridEngine/Devices/multi_circuit.py

@@ -17,7 +17,6 @@ from scipy.sparse import csc_matrix, lil_matrix
 
 from VeraGridEngine.Devices.assets import Assets
 from VeraGridEngine.Devices.Parents.editable_device import EditableDevice
-from VeraGridEngine.Utils.Symbolic import Var
 from VeraGridEngine.basic_structures import IntVec, Vec, Mat, CxVec, IntMat, CxMat
 
 import VeraGridEngine.Devices as dev
@@ -76,7 +75,7 @@ def get_fused_device_lst(elm_list: List[INJECTION_DEVICE_TYPES], property_names:
             act_final = bool(act_final + elm2.active)  # equivalent to OR
 
             if act_prof_final is not None:
-                act_prof_final = (act_prof_final.toarray() + elm2.active_prof.toarray()).astype(bool)
+                act_prof_final = (act_prof_final + elm2.active_prof.toarray()).astype(bool)
 
         for prop in property_names:  # sum the properties
 
@@ -860,7 +859,7 @@ class MultiCircuit(Assets):
         Get the branch-bus dictionary
         :return: dict[bus] -> list of branches
         """
-        d: Dict[dev.Bus, List[dev.BranchType]] = {b: list() for b in self._buses}
+        d: Dict[dev.Bus, List[BRANCH_TYPES]] = {b: list() for b in self._buses}
 
         for branch_list in self.get_branch_lists(add_vsc=True, add_hvdc=True, add_switch=True):
             for br in branch_list:
@@ -3075,3 +3074,95 @@ class MultiCircuit(Assets):
                 branch_active, branch_F, branch_T,
                 hvdc_active, hvdc_F, hvdc_T,
                 vsc_active, vsc_F, vsc_T)
+
+    def move_behind_converter(self, api_object: INJECTION_DEVICE_TYPES) -> Tuple[dev.Bus, dev.VSC]:
+        """
+
+        :param api_object:
+        :return:
+        """
+        old_bus = api_object.bus
+        new_bus = dev.Bus(
+            name=old_bus.name + "_dc",
+            Vnom=old_bus.Vnom,
+            is_dc=True,
+            xpos=old_bus.x,
+            ypos=old_bus.y + 20,
+        )
+        self.add_bus(obj=new_bus)
+
+        converter = dev.VSC(
+            name=api_object.name,
+            bus_from=new_bus,
+            bus_to=old_bus,
+            control1=ConverterControlType.Vm_dc,
+            control2=ConverterControlType.Qac,
+            control1_val=1.0,
+            rate=9999.0
+        )
+        self.add_vsc(obj=converter)
+
+        if api_object.device_type == DeviceType.LoadDevice:
+            converter.control2_val = api_object.P
+            if self.has_time_series:
+                converter.control2_val_prof = api_object.P_prof.toarray()
+
+        if api_object.device_type == DeviceType.StaticGeneratorDevice:
+            converter.control2_val = -1 * api_object.P
+            if self.has_time_series:
+                converter.control2_val_prof = -1 * api_object.P_prof.toarray()
+
+        # set the API object new bus
+        api_object.bus = new_bus
+
+        return new_bus, converter
+
+    def slice_buses(self, buses: List[dev.Bus]) -> "MultiCircuit":
+        """
+        Get a subset of the grid
+        :param buses: list of buses to slice te grid
+        :return: new MultiCircuit
+        """
+        other = MultiCircuit()
+
+        bus_set = set(buses)
+
+        # add the branches and extend the set of buses
+        for br in self.get_branches_iter(add_vsc=True, add_hvdc=True, add_switch=True):
+
+            if br.bus_from in bus_set:
+                bus_set.add(br.bus_to)
+                other.add_element(br)
+
+            elif br.bus_to in bus_set:
+                bus_set.add(br.bus_from)
+                other.add_element(br)
+
+            else:
+                pass
+
+        # search for voltage levels and substations
+        vl_set = set()
+        se_set = set()
+        for bus in bus_set:
+            other.add_bus(bus)
+
+            if bus.voltage_level is not None:
+                vl_set.add(bus.voltage_level)
+                if bus.substation is not None:
+                    se_set.add(bus.substation)
+
+        # add substations
+        for se in se_set:
+            other.add_substation(se)
+
+        # add voltage level
+        for vl in vl_set:
+            other.add_voltage_level(vl)
+
+        # add injections
+        for inj in self.get_injection_devices_iter():
+            if inj.bus in bus_set:
+                other.add_element(inj)
+
+        return other