VeraGridEngine 6.0.2__tar.gz → 6.0.3__tar.gz

{veragridengine-6.0.2 → veragridengine-6.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 6.0.2
+Version: 6.0.3
 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-6.0.2 → veragridengine-6.0.3}/VeraGridEngine/Compilers/circuit_to_bentayga.py

@@ -403,7 +403,7 @@ def get_vsc_data(
                       Pf_set=elm.Pdc_set,
                       vac_set=elm.Vac_set,
                       vdc_set=elm.Vdc_set,
-                      kdp=elm.kdp,
+                      kdp=elm.control1_droop,
                       alpha1=elm.alpha1,
                       alpha2=elm.alpha2,
                       alpha3=elm.alpha3)

{veragridengine-6.0.2 → veragridengine-6.0.3}/VeraGridEngine/Compilers/circuit_to_data.py

@@ -293,7 +293,8 @@ def get_bus_data(bus_data: BusData,
                  circuit: MultiCircuit,
                  areas_dict: Dict[Area, int],
                  t_idx: int | None,
-                 use_stored_guess=False, ) -> None:
+                 use_stored_guess=False,
+                 consider_grounded_buses: bool = False) -> None:
     """
 
     :param bus_data: BusData
@@ -301,6 +302,7 @@ def get_bus_data(bus_data: BusData,
     :param areas_dict:
     :param t_idx:
     :param use_stored_guess:
+    :param consider_grounded_buses:
     :return:
     """
 
@@ -319,7 +321,7 @@ def get_bus_data(bus_data: BusData,
         bus_data.is_grounded[i] = bus.is_grounded
 
         # Grounded buses go to zero
-        if bus.is_grounded:
+        if bus.is_grounded and consider_grounded_buses and bus.is_dc:
             bus_data.Vbus[i] = 1e-20 * np.exp(1j * 1e-20)  # effectively zero
 
         bus_data.angle_min[i] = bus.angle_min
@@ -1026,6 +1028,15 @@ def fill_generator_parent(
     data.x1[k] = elm.X1
     data.x2[k] = elm.X2
 
+    # asynchronous generator impedance
+    data.Rs[k] = elm.Rs
+    data.Xs[k] = elm.Xs
+    data.Xm[k] = elm.Xm
+    data.Rr[k] = elm.Rr
+    data.Xr[k] = elm.Xr
+
+    data.type[k] = elm.tpe
+
     data.startup_cost[k] = elm.startup_cost
     data.shut_down_cost[k] = elm.shutdown_cost
 
@@ -1952,8 +1963,21 @@ def get_vsc_data(
 
         data.control1[ii] = elm.get_control1_at(t_idx)
         data.control2[ii] = elm.get_control2_at(t_idx)
+        data.fault_control[ii] = elm.get_fault_control_at(t_idx)
         data.control1_val[ii] = elm.get_control1_val_at(t_idx)
         data.control2_val[ii] = elm.get_control2_val_at(t_idx)
+        data.control1_val_min[ii] = elm.control1_val_min
+        data.control1_val_max[ii] = elm.control1_val_max
+        data.control1_droop[ii] = elm.get_control1_droop_at(t_idx)
+        data.control1_droop_val[ii] = elm.get_control1_droop_val_at(t_idx)
+        data.control1_droop_val_min[ii] = elm.control1_droop_val_min
+        data.control1_droop_val_max[ii] = elm.control1_droop_val_max
+        data.control2_val_min[ii] = elm.control2_val_min
+        data.control2_val_max[ii] = elm.control2_val_max
+        data.control2_val_droop[ii] = elm.get_control2_val_droop_at(t_idx)
+        data.control2_droop_val[ii] = elm.get_control2_droop_val_at(t_idx)
+        data.control2_droop_val_min[ii] = elm.control2_droop_val_min
+        data.control2_droop_val_max[ii] = elm.control2_droop_val_max
 
         # Using DC_positive to set the controls, may need to also pass DC_negative
         set_control_dev(k=ii, f=f, t=t,
@@ -1985,12 +2009,14 @@ def get_vsc_data(
         data.contingency_enabled[i] = int(elm.contingency_enabled)
         data.monitor_loading[i] = int(elm.monitor_loading)
 
-        data.Kdp[ii] = elm.kdp
+        # data.Kdp[ii] = elm.kdp
         data.alpha1[ii] = elm.alpha1
         data.alpha2[ii] = elm.alpha2
         data.alpha3[ii] = elm.alpha3
         data.min_ac_voltage[ii] = elm.min_ac_voltage
 
+        data.ysvs[ii] = elm.ysvs
+
         ii += 1
 
 
@@ -2224,6 +2250,7 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
                                  control_remote_voltage: bool = True,
                                  fill_gep: bool = False,
                                  fill_three_phase: bool = False,
+                                 consider_grounded_buses: bool = False,
                                  logger=Logger()) -> NumericalCircuit:
     """
     Compile a NumericalCircuit from a MultiCircuit
@@ -2240,6 +2267,7 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
     :param control_remote_voltage: control remote voltage?
     :param fill_gep: fill generation expansion planning parameters?
     :param fill_three_phase:
+    :param consider_grounded_buses: Consider the is_grounded bus state
     :param logger: Logger instance
     :return: NumericalCircuit instance
     """
@@ -2283,6 +2311,7 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
         t_idx=t_idx,
         areas_dict=areas_dict,
         use_stored_guess=use_stored_guess,
+        consider_grounded_buses=consider_grounded_buses
     )
 
     gen_dict = get_generator_data(

{veragridengine-6.0.2 → veragridengine-6.0.3}/VeraGridEngine/Compilers/circuit_to_gslv.py

@@ -1766,7 +1766,7 @@ def convert_vsc(elm: dev.VSC, bus_dict: Dict[str, "pg.Bus"], n_time: int,
         code=str(elm.code),
         active=elm.active,
         rate=9999.0,
-        kdp=elm.kdp,
+        kdp=elm.control1_droop,
         alpha1=elm.alpha1,
         alpha2=elm.alpha2,
         alpha3=elm.alpha3,

{veragridengine-6.0.2 → veragridengine-6.0.3}/VeraGridEngine/Compilers/circuit_to_newton_pa.py

@@ -816,7 +816,7 @@ def add_vsc_data(circuit: MultiCircuit,
         vsc.setAllPdcSet(elm.Pset)
         vsc.setAllVacSet(elm.vset)
         vsc.setAllVdcSet(elm.vset)
-        vsc.k_droop = elm.kdp
+        vsc.k_droop = elm.control1_droop
 
         vsc.alpha1 = elm.alpha1
         vsc.alpha2 = elm.alpha2

{veragridengine-6.0.2 → veragridengine-6.0.3}/VeraGridEngine/DataStructures/generator_data.py

@@ -7,7 +7,8 @@ from typing import Tuple
 import numpy as np
 from scipy.sparse import csc_matrix, coo_matrix
 import VeraGridEngine.Topology.topology as tp
-from VeraGridEngine.basic_structures import CxVec, Vec, IntVec, BoolVec, StrVec
+from VeraGridEngine.basic_structures import CxVec, Vec, IntVec, BoolVec, StrVec, ObjVec
+from VeraGridEngine.enumerations import GeneratorType
 
 
 class GeneratorData:
@@ -59,6 +60,15 @@ class GeneratorData:
         self.x1: Vec = np.zeros(nelm, dtype=float)
         self.x2: Vec = np.zeros(nelm, dtype=float)
 
+        # asynchronous generator impedance
+        self.Rs: Vec = np.zeros(nelm, dtype=float)
+        self.Xs: Vec = np.zeros(nelm, dtype=float)
+        self.Xm: Vec = np.zeros(nelm, dtype=float)
+        self.Rr: Vec = np.zeros(nelm, dtype=float)
+        self.Xr: Vec = np.zeros(nelm, dtype=float)
+
+        self.type: ObjVec = np.full(self.nelm, fill_value=GeneratorType.Synchronous, dtype=object)
+
         self.dispatchable: BoolVec = np.zeros(nelm, dtype=bool)
         self.must_run: BoolVec = np.zeros(nelm, dtype=bool)
         self.pmax: Vec = np.zeros(nelm, dtype=float)
@@ -140,6 +150,14 @@ class GeneratorData:
         data.x1 = self.x1[elm_idx]
         data.x2 = self.x2[elm_idx]
 
+        data.Rs = self.Rs[elm_idx]
+        data.Xs = self.Xs[elm_idx]
+        data.Xm = self.Xm[elm_idx]
+        data.Rr = self.Rr[elm_idx]
+        data.Xr = self.Xr[elm_idx]
+
+        data.type = self.type[elm_idx]
+
         data.dispatchable = self.dispatchable[elm_idx]
         data.must_run = self.must_run[elm_idx]
         data.pmax = self.pmax[elm_idx]
@@ -225,6 +243,14 @@ class GeneratorData:
         data.x1 = self.x1.copy()
         data.x2 = self.x2.copy()
 
+        data.Rs = self.Rs.copy()
+        data.Xs = self.Xs.copy()
+        data.Xm = self.Xm.copy()
+        data.Rr = self.Rr.copy()
+        data.Xr = self.Xr.copy()
+
+        data.type = self.type.copy()
+
         data.dispatchable = self.dispatchable.copy()
         data.must_run = self.must_run.copy()
         data.pmax = self.pmax.copy()

{veragridengine-6.0.2 → veragridengine-6.0.3}/VeraGridEngine/DataStructures/vsc_data.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import numpy as np
 from VeraGridEngine.DataStructures.branch_parent_data import BranchParentData
-from VeraGridEngine.enumerations import ConverterControlType
+from VeraGridEngine.enumerations import ConverterControlType, ConverterFaultControlType
 from VeraGridEngine.basic_structures import Vec, IntVec, ObjVec, Logger
 
 
@@ -26,16 +26,29 @@ class VscData(BranchParentData):
 
         self.F_dcn = np.zeros(self.nelm, dtype=int)
 
-        self.Kdp: Vec = np.ones(self.nelm, dtype=float)
         self.alpha1: Vec = np.zeros(self.nelm, dtype=float)  # converter losses parameter (alpha1) (idle loss)
         self.alpha2: Vec = np.zeros(self.nelm, dtype=float)  # converter losses parameter (alpha2) (switching loss)
         self.alpha3: Vec = np.zeros(self.nelm, dtype=float)  # converter losses parameter (alpha3) (resistive loss)
 
         self.control1: ObjVec = np.full(self.nelm, fill_value=ConverterControlType.Vm_dc, dtype=object)
         self.control2: ObjVec = np.full(self.nelm, fill_value=ConverterControlType.Pac, dtype=object)
+        self.fault_control: ObjVec = np.full(self.nelm, fill_value=ConverterFaultControlType.Standard, dtype=object)
 
         self.control1_val: Vec = np.ones(self.nelm, dtype=float)
         self.control2_val: Vec = np.ones(self.nelm, dtype=float)
+        self.control1_val_min: Vec = np.zeros(self.nelm, dtype=float)
+        self.control1_val_max: Vec = np.full(self.nelm, 9999.0, dtype=float)
+        self.control1_droop: Vec = np.full(self.nelm, 0.1, dtype=float)
+        self.control1_droop_val: Vec = np.ones(self.nelm, dtype=float)
+        self.control1_droop_val_min: Vec = np.full(self.nelm, 0.9, dtype=float)
+        self.control1_droop_val_max: Vec = np.full(self.nelm, 1.1, dtype=float)
+
+        self.control2_val_min: Vec = np.zeros(self.nelm, dtype=float)
+        self.control2_val_max: Vec = np.full(self.nelm, 9999.0, dtype=float)
+        self.control2_val_droop: Vec = np.full(self.nelm, 0.1, dtype=float)
+        self.control2_droop_val: Vec = np.ones(self.nelm, dtype=float)
+        self.control2_droop_val_min: Vec = np.full(self.nelm, 0.9, dtype=float)
+        self.control2_droop_val_max: Vec = np.full(self.nelm, 1.1, dtype=float)
 
         self.control1_bus_idx: IntVec = np.full(nelm, -1, dtype=int)
         self.control2_bus_idx: IntVec = np.full(nelm, -1, dtype=int)
@@ -44,6 +57,8 @@ class VscData(BranchParentData):
 
         self.min_ac_voltage: Vec = np.full(self.nelm, 0.1, dtype=float)
 
+        self.ysvs: Vec = np.full(self.nelm, 0.0, dtype=float)
+
     def slice(self, elm_idx: IntVec, bus_idx: IntVec, bus_map: IntVec, logger: Logger | None) -> "VscData":
         """
         Slice branch data by given indices
@@ -62,16 +77,29 @@ class VscData(BranchParentData):
         data.F_dcn = self.F_dcn[elm_idx]
         # data.T_ac = self.T_ac[elm_idx]
 
-        data.Kdp = self.Kdp[elm_idx]
         data.alpha1 = self.alpha1[elm_idx]
         data.alpha2 = self.alpha2[elm_idx]
         data.alpha3 = self.alpha3[elm_idx]
 
         data.control1 = self.control1[elm_idx]
         data.control2 = self.control2[elm_idx]
+        data.fault_control = self.fault_control[elm_idx]
 
         data.control1_val = self.control1_val[elm_idx]
         data.control2_val = self.control2_val[elm_idx]
+        data.control1_val_min = self.control1_val_min[elm_idx]
+        data.control1_val_max = self.control1_val_max[elm_idx]
+        data.control1_droop = self.control1_droop[elm_idx]
+        data.control1_droop_val = self.control1_droop_val[elm_idx]
+        data.control1_droop_val_min = self.control1_droop_val_min[elm_idx]
+        data.control1_droop_val_max = self.control1_droop_val_max[elm_idx]
+
+        data.control2_val_min = self.control2_val_min[elm_idx]
+        data.control2_val_max = self.control2_val_max[elm_idx]
+        data.control2_val_droop = self.control2_val_droop[elm_idx]
+        data.control2_droop_val = self.control2_droop_val[elm_idx]
+        data.control2_droop_val_min = self.control2_droop_val_min[elm_idx]
+        data.control2_droop_val_max = self.control2_droop_val_max[elm_idx]
 
         data.control1_bus_idx = self.control1_bus_idx[elm_idx]
         data.control2_bus_idx = self.control2_bus_idx[elm_idx]
@@ -82,6 +110,8 @@ class VscData(BranchParentData):
 
         data.min_ac_voltage = self.min_ac_voltage[elm_idx]
 
+        data.ysvs = self.ysvs[elm_idx]
+
         for k in range(data.nelm):
             if data.control1_bus_idx[k] > -1:
                 data.control1_bus_idx[k] = bus_map[data.control1_bus_idx[k]]
@@ -111,7 +141,6 @@ class VscData(BranchParentData):
 
         data.F_dcn = self.F_dcn.copy()
 
-        data.Kdp = self.Kdp.copy()
         data.dc = self.dc.copy()
         data.alpha1 = self.alpha1.copy()
         data.alpha2 = self.alpha2.copy()
@@ -119,9 +148,22 @@ class VscData(BranchParentData):
 
         data.control1 = self.control1.copy()
         data.control2 = self.control2.copy()
+        data.fault_control = self.fault_control.copy()
 
         data.control1_val = self.control1_val.copy()
         data.control2_val = self.control2_val.copy()
+        data.control1_val_min = self.control1_val_min.copy()
+        data.control1_val_max = self.control1_val_max.copy()
+        data.control1_droop = self.control1_droop.copy()
+        data.control1_droop_val = self.control1_droop_val.copy()
+        data.control1_droop_val_min = self.control1_droop_val_min.copy()
+        data.control1_droop_val_max = self.control1_droop_val_max.copy()
+        data.control2_val_min = self.control2_val_min.copy()
+        data.control2_val_max = self.control2_val_max.copy()
+        data.control2_val_droop = self.control2_val_droop.copy()
+        data.control2_droop_val = self.control2_droop_val.copy()
+        data.control2_droop_val_min = self.control2_droop_val_min.copy()
+        data.control2_droop_val_max = self.control2_droop_val_max.copy()
 
         data.control1_bus_idx = self.control1_bus_idx.copy()
         data.control2_bus_idx = self.control2_bus_idx.copy()
@@ -130,6 +172,8 @@ class VscData(BranchParentData):
 
         data.min_ac_voltage = self.min_ac_voltage.copy()
 
+        data.ysvs = self.ysvs.copy()
+
         return data
 
     def __len__(self) -> int:

{veragridengine-6.0.2 → veragridengine-6.0.3}/VeraGridEngine/Devices/Branches/tap_changer.py

@@ -204,6 +204,15 @@ class TapChanger:
         """
         return self._tau_array
 
+    @property
+    def impedance_correction_imag_array(self) -> np.ndarray:
+        """
+        Get the imaginary impedance correction factors per tap position.
+        A value of 1.0 at every position means no correction (default).
+        :return: array of length total_positions
+        """
+        return self._k_im_array
+
     def resize(self) -> None:
         """
         Resize and recalc the tap positions array