VeraGridEngine 5.5.14__tar.gz → 5.5.15__tar.gz

{veragridengine-5.5.14 → veragridengine-5.5.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.5.14
+Version: 5.5.15
 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.5.14 → veragridengine-5.5.15}/VeraGridEngine/Devices/Branches/underground_line_type.py

@@ -11,18 +11,22 @@ class UndergroundLineType(EditableDevice):
     __slots__ = (
         'Imax',
         'Vnom',
+        '_freq',
         'R',
         'X',
         'B',
+        '_C',
         'R0',
         'X0',
         'B0',
+        '_C0',
         'n_circuits'
     )
 
     def __init__(self, name: str = 'UndergroundLine', idtag: None | str = None, Imax: float = 1.0,
-                 Vnom: float = 1.0, R: float = 0.0, X: float = 0.0, B: float = 0.0,
-                 R0: float = 0.0, X0: float = 0.0, B0: float = 0.0) -> None:
+                 Vnom: float = 1.0, R: float = 0.0, X: float = 0.0, B: float = 0.0, C: float = 0.0,
+                 R0: float = 0.0, X0: float = 0.0, B0: float = 0.0, C0: float = 0.0,
+                 freq: float = 50.0) -> None:
         """
         Constructor
         :param name: name of the device
@@ -30,9 +34,12 @@ class UndergroundLineType(EditableDevice):
         :param R: Resistance of positive sequence in Ohm/km
         :param X: Reactance of positive sequence in Ohm/km
         :param B: Susceptance of positive sequence in uS/km
+        :param C: Capacitance of positive sequence in uF/km (alternative to B)
         :param R0: Resistance of zero sequence in Ohm/km
         :param X0: Reactance of zero sequence in Ohm/km
         :param B0: Susceptance of zero sequence in uS/km
+        :param C0: Capacitance of zero sequence in uF/km (alternative to B0)
+        :param freq: Frequency of underground line (Hz)
         """
         EditableDevice.__init__(self,
                                 name=name,
@@ -42,26 +49,34 @@ class UndergroundLineType(EditableDevice):
 
         self.Imax = float(Imax)
         self.Vnom = float(Vnom)
+        self._freq = float(freq)
 
         # impudence and admittance per unit of length
         self.R = float(R)
         self.X = float(X)
         self.B = float(B)
+        self._C = float(C)
 
         self.R0 = float(R0)
         self.X0 = float(X0)
         self.B0 = float(B0)
+        self._C0 = float(C0)
 
         self.n_circuits = 1
 
         self.register(key='Imax', units='kA', tpe=float, definition='Current rating of the line', old_names=['rating'])
         self.register(key='Vnom', units='kV', tpe=float, definition='Voltage rating of the line')
+        self.register(key='freq', units='Hz', tpe=float, definition='Cable frequency')
         self.register(key='R', units='Ohm/km', tpe=float, definition='Positive-sequence resistance per km')
         self.register(key='X', units='Ohm/km', tpe=float, definition='Positive-sequence reactance per km')
         self.register(key='B', units='uS/km', tpe=float, definition='Positive-sequence shunt susceptance per km')
+        self.register(key='C', units='uF/km', tpe=float,
+                      definition='Positive-sequence shunt capacitance per km (alternative to B')
         self.register(key='R0', units='Ohm/km', tpe=float, definition='Zero-sequence resistance per km')
         self.register(key='X0', units='Ohm/km', tpe=float, definition='Zero-sequence reactance per km')
         self.register(key='B0', units='uS/km', tpe=float, definition='Zero-sequence shunt susceptance per km')
+        self.register(key='C0', units='uF/km', tpe=float,
+                      definition='Zero-sequence shunt capacitance per km (alternative to B0')
         self.register(key='n_circuits', units='', tpe=int, definition='number of circuits')
 
     def get_values(self, Sbase: float, length: float):
@@ -100,19 +115,36 @@ class UndergroundLineType(EditableDevice):
         """
         return 1j * self.B
 
-    def change_base(self, Sbase_old, Sbase_new):
-        """
-        change the per unit base
-        :param Sbase_old: old base in MVA
-        :param Sbase_new: new base in MVA
-        """
-        b = Sbase_new / Sbase_old
+    @property
+    def C(self) -> float:
+        return self._C
+
+    @C.setter
+    def C(self, C: float):
+        self._C = float(C)
+
+        if self.auto_update_enabled:
+            self.B = 2 * np.pi * self._freq * self._C
+
+    @property
+    def C0(self) -> float:
+        return self._C0
+
+    @C0.setter
+    def C0(self, C0: float):
+        self._C0 = float(C0)
+
+        if self.auto_update_enabled:
+            self.B0 = 2 * np.pi * self._freq * self._C0
 
-        self.R *= b
-        self.X *= b
-        self.B *= b
+    @property
+    def freq(self) -> float:
+        return self._freq
 
-        self.R0 *= b
-        self.X0 *= b
-        self.B0 *= b
+    @freq.setter
+    def freq(self, freq: float):
+        self._freq = float(freq)
 
+        if self.auto_update_enabled:
+            self.B = 2 * np.pi * self._freq * self._C
+            self.B0 = 2 * np.pi * self._freq * self._C0

{veragridengine-5.5.14 → veragridengine-5.5.15}/VeraGridEngine/Devices/Injections/load.py

@@ -4,7 +4,6 @@
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
 
-import pdb
 from typing import Union, List
 import numpy as np
 import pandas as pd
@@ -12,7 +11,7 @@ from matplotlib import pyplot as plt
 from VeraGridEngine.enumerations import DeviceType, BuildStatus
 from VeraGridEngine.Devices.Parents.load_parent import LoadParent
 from VeraGridEngine.Devices.profile import Profile
-from VeraGridEngine.Utils.Symbolic.block import Block, Var, Const, DynamicVarType
+from VeraGridEngine.Utils.Symbolic.block import Block, Var, DynamicVarType
 from VeraGridEngine.Utils.Symbolic.symbolic import piecewise
 from VeraGridEngine.Devices.Parents.editable_device import get_at
 
@@ -58,6 +57,7 @@ class Load(LoadParent):
         '_Ir3_prof',
         '_Ii3_prof',
 
+        '_contract_power',
         '_n_customers',
         '_n_customers_prof',
 
@@ -72,7 +72,9 @@ class Load(LoadParent):
                  G1=0.0, G2=0.0, G3=0.0, B1=0.0, B2=0.0, B3=0.0,
                  Ir1=0.0, Ir2=0.0, Ir3=0.0, Ii1=0.0, Ii2=0.0, Ii3=0.0, Pl0=1.0, Ql0=1.0,
                  active=True, mttf=0.0, mttr=0.0, capex=0, opex=0,
-                 init_params: dict[str, float] = {},
+                 n_customers: int = 0,
+                 contracted_power: float = 0.0,
+                 init_params: dict[str, float] | None = None,
                  build_status: BuildStatus = BuildStatus.Commissioned):
         """
         The load object implements the so-called ZIP model, in which the load can be
@@ -166,13 +168,15 @@ class Load(LoadParent):
         self._Ii2_prof = Profile(default_value=self.Ii2, data_type=float)
         self._Ii3_prof = Profile(default_value=self.Ii3, data_type=float)
 
-        self._n_customers: int = 1
+        self._n_customers: int = n_customers
         self._n_customers_prof = Profile(default_value=self._n_customers, data_type=int)
 
+        self._contract_power: float = contracted_power
+
         self.Pl0 = Pl0
         self.Ql0 = Ql0
 
-        self.init_params = init_params
+        self.init_params = init_params if init_params is not None else dict()
 
         self.register(key='Ir', units='MW', tpe=float,
                       definition='Active power of the current component at V=1.0 p.u.', profile_name='Ir_prof')
@@ -217,6 +221,7 @@ class Load(LoadParent):
                       profile_name='B3_prof')
         self.register(key='n_customers', units='unit', tpe=int,
                       definition='Number of customers represented by this load', profile_name='n_customers_prof')
+        self.register(key='contract_power', units='MW', tpe=float, definition='Nominal contracted power', )
 
     @property
     def Ir_prof(self) -> Profile:
@@ -701,6 +706,28 @@ class Load(LoadParent):
         except ValueError as e:
             print(e)
 
+    @property
+    def contract_power(self) -> float:
+        """
+        Return the contracted power
+        """
+        return self._contract_power
+
+    @contract_power.setter
+    def contract_power(self, val: float):
+        """
+        Set the contracted power
+        :param val: value greater than 0
+        """
+        try:
+            val2 = float(val)
+            if val2 > 0:
+                self._contract_power = val2
+            else:
+                print("Do they contract negative power?")
+        except ValueError as e:
+            print(e)
+
     @property
     def n_customers_prof(self) -> Profile:
         """

{veragridengine-5.5.14 → veragridengine-5.5.15}/VeraGridEngine/Topology/GridReduction/ptdf_grid_reduction.py

@@ -342,6 +342,9 @@ def ptdf_reduction_projected(grid: MultiCircuit,
     Flow0_gen = lin.get_flows(Pgen)
     Flow0_gen_srap = lin.get_flows(Pgen_srap)
 
+    # Flows0 = lin.PTDF @ Pbus0
+    # Flows0_check = Flow0_load + Flow0_gen + Flow0_gen_srap
+
     if grid.has_time_series:
         Pload_ts = get_Pload_ts(grid)
         Pgen_ts, Pgen_srap_ts = get_Pgen_ts(grid)
@@ -373,9 +376,9 @@ def ptdf_reduction_projected(grid: MultiCircuit,
     X, _, _, _ = np.linalg.lstsq(lin2.PTDF, b)
     Pbus3_load, Pbus3_gen, Pbus3_gen_srap = X[:, 0], X[:, 1], X[:, 2]
 
-    dPload = Pbus_load2 - Pbus3_load
-    dPgen = Pbus_gen2 - Pbus3_gen
-    dPgen_srap = Pbus_gen_srap2 - Pbus3_gen_srap
+    dPload = Pbus3_load - Pbus_load2
+    dPgen = Pbus3_gen - Pbus_gen2
+    dPgen_srap = Pbus3_gen_srap - Pbus_gen_srap2
 
     if grid.has_time_series:
 
@@ -409,8 +412,7 @@ def ptdf_reduction_projected(grid: MultiCircuit,
             grid.add_load(bus=bus, api_obj=elm)
 
         if abs(dPgen[i]) > tol:
-            elm = Generator(name=f"compensated gen {i}", P=dPgen[i], srap_enabled=False, 
-                            is_controlled=False, power_factor=0.999)
+            elm = Generator(name=f"compensated gen {i}", P=dPgen[i], srap_enabled=False)
 
             if dPbus_gen_ts is not None:
                 elm.P_prof = -dPbus_gen_ts[:, i]
@@ -418,8 +420,7 @@ def ptdf_reduction_projected(grid: MultiCircuit,
             grid.add_generator(bus=bus, api_obj=elm)
 
         if abs(dPgen_srap[i]) > tol:
-            elm = Generator(name=f"compensated gen {i}", P=dPgen_srap[i], srap_enabled=True,
-                            is_controlled=False, power_factor=0.999)
+            elm = Generator(name=f"compensated gen {i}", P=dPgen_srap[i], srap_enabled=True)
 
             if dPbus_gen_srap_ts is not None:
                 elm.P_prof = -dPbus_gen_srap_ts[:, i]
@@ -431,8 +432,6 @@ def ptdf_reduction_projected(grid: MultiCircuit,
     # Flows0 = lin.PTDF @ Pbus0
     # Flows4 = lin2.PTDF @ Pbus4
     # diff = Flows0[i_branches] - Flows4
-    
-    
 
     return grid, logger
 

{veragridengine-5.5.14 → veragridengine-5.5.15}/VeraGridEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # remember to keep a three-number version!!!
-__VeraGridEngine_VERSION__ = "5.5.14"
+__VeraGridEngine_VERSION__ = "5.5.15"
 
 url = 'https://github.com/SanPen/VeraGrid'