latest changes from eroots repo

Author: SanPen

README.md

@@ -14,7 +14,7 @@ product of cutting-edge research.
 [![Documentation Status](https://readthedocs.org/projects/veragrid/badge/?version=latest)](https://veragrid.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/SanPen/VeraGrid.svg?branch=master)](https://travis-ci.org/SanPen/VeraGrid)
 [![DOI](https://www.zenodo.org/badge/49583206.svg)](https://www.zenodo.org/badge/latestdoi/49583206)
 [![Downloads](https://static.pepy.tech/personalized-badge/veragrid?period=total&units=abbreviation&left_color=grey&right_color=green&left_text=Downloads)](https://pepy.tech/project/veragrid)
-[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg)](https://discord.gg/sVnwkaxN)
+[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg)](https://discord.gg/ypgmWvT5)
 
 VeraGrid started in 2015 with a clear objective: create a solid programming library and a user-friendly interface.
 This straightforward approach sparked many innovations — some driven by the necessity
@@ -1467,7 +1467,7 @@ All contributions must come with testing.
 
 ## Contact
 
-- Join the [Discord VeraGrid channel](https://discord.com/invite/dzxctaNbvu) for a friendly chat, or quick question.
+- Join the [Discord VeraGrid channel](https://discord.gg/ypgmWvT5) for a friendly chat, or quick question.
 - Submit questions or comments to our [form](https://forms.gle/MpjJAntAwZiLwE6B6).
 - Submit bugs or requests in the [Issues](https://github.com/SanPen/VeraGrid/issues) section.
 

src/VeraGridEngine/Compilers/circuit_to_gslv.py

@@ -2321,6 +2321,7 @@ def gslv_pf(circuit: MultiCircuit,
             logger: Logger = Logger()) -> "pg.PowerFlowResults":
     """
     GSLV power flow
+    :param logger:
     :param circuit: MultiCircuit instance
     :param pf_opt: Power Flow Options
     :param time_series: Compile with VeraGrid time series?
@@ -2407,7 +2408,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.Pf_vsc[0, :]
     results.St_vsc = res.St_vsc[0, :]
     results.loading_vsc = res.loading_vsc[0, :]
     results.losses_vsc = res.losses_vsc[0, :]

src/VeraGridEngine/Devices/Branches/line.py

@@ -662,8 +662,16 @@ def get_equivalent_transformer(self, index: pd.DatetimeIndex | None = None) -> T
 
         return elm
 
-    def fill_design_properties(self, r_ohm: float, x_ohm: float, c_nf: float, length: float,
-                               Imax: float, freq: float, Sbase: float, apply_to_profile: bool = True, ) -> "Line":
+    def fill_design_properties(self,
+                               r_ohm: float,
+                               x_ohm: float,
+                               c_nf: float,
+                               length: float,
+                               Imax: float,
+                               freq: float,
+                               Sbase: float,
+                               apply_to_profile: bool = True,
+                               logger: Logger = Logger()) -> "Line":
         """
         Fill R, X, B from not-in-per-unit parameters
         :param r_ohm: Resistance per km in OHM/km
@@ -674,28 +682,36 @@ def fill_design_properties(self, r_ohm: float, x_ohm: float, c_nf: float, length
         :param freq: System frequency in Hz
         :param Sbase: Base power in MVA (take always 100 MVA)
         :param apply_to_profile: modify the ratings profile if checked
+        :param logger: Logger
         :return self pointer
         """
-        self.R, self.X, self.B, new_rate = get_line_impedances_with_c(r_ohm=r_ohm,
-                                                                      x_ohm=x_ohm,
-                                                                      c_nf=c_nf,
-                                                                      length=length,
-                                                                      Imax=Imax,
-                                                                      freq=freq,
-                                                                      Sbase=Sbase,
-                                                                      Vnom=self.get_max_bus_nominal_voltage())
+        Vnom = self.get_max_bus_nominal_voltage()
 
-        old_rate = float(self.rate)
+        if Vnom > 0:
 
-        self.rate = new_rate
-        self._length = length
+            self.R, self.X, self.B, new_rate = get_line_impedances_with_c(r_ohm=r_ohm,
+                                                                          x_ohm=x_ohm,
+                                                                          c_nf=c_nf,
+                                                                          length=length,
+                                                                          Imax=Imax,
+                                                                          freq=freq,
+                                                                          Sbase=Sbase,
+                                                                          Vnom=Vnom,
+                                                                          logger=logger)
 
-        if apply_to_profile:
-            if old_rate != 0.0:
-                prof_old = self.rate_prof.toarray()
-                self.rate_prof.set(prof_old * new_rate / old_rate)
-            else:
-                self.rate_prof.fill(new_rate)
+            old_rate = float(self.rate)
+
+            self.rate = new_rate
+            self._length = length
+
+            if apply_to_profile:
+                if old_rate != 0.0:
+                    prof_old = self.rate_prof.toarray()
+                    self.rate_prof.set(prof_old * new_rate / old_rate)
+                else:
+                    self.rate_prof.fill(new_rate)
+        else:
+            logger.add_error("Nominal voltage is zero", device_class="Line", device=self.name)
 
         return self
 

src/VeraGridEngine/Devices/Branches/sequence_line_type.py

@@ -6,11 +6,18 @@
 import numpy as np
 from VeraGridEngine.Devices.admittance_matrix import AdmittanceMatrix
 from VeraGridEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
-
-
-def get_line_impedances_with_c(r_ohm: float, x_ohm: float, c_nf: float,
-                               length: float, Imax: float,
-                               freq: float, Sbase: float, Vnom: float) -> Tuple[float, float, float, float]:
+from VeraGridEngine.basic_structures import Logger
+
+
+def get_line_impedances_with_c(r_ohm: float,
+                               x_ohm: float,
+                               c_nf: float,
+                               length: float,
+                               Imax: float,
+                               freq: float,
+                               Sbase: float,
+                               Vnom: float,
+                               logger: Logger = Logger()) -> Tuple[float, float, float, float]:
     """
     Fill R, X, B from not-in-per-unit parameters
     :param r_ohm: Resistance per km in OHM/km
@@ -21,26 +28,31 @@ def get_line_impedances_with_c(r_ohm: float, x_ohm: float, c_nf: float,
     :param freq: System frequency in Hz
     :param Sbase: Base power in MVA (take always 100 MVA)
     :param Vnom: nominal voltage (kV)
+    :param logger: logger
     :return R, X, B, rate
     """
     r_ohm_total = r_ohm * length
     x_ohm_total = x_ohm * length
     b_siemens_total = (2 * np.pi * freq * c_nf * 1e-9) * length
 
-    Zbase = (Vnom * Vnom) / Sbase
-    Ybase = 1.0 / Zbase
-
-    R = np.round(r_ohm_total / Zbase, 6)
-    X = np.round(x_ohm_total / Zbase, 6)
-    B = np.round(b_siemens_total / Ybase, 6)
+    if Vnom > 0.0:
+        Zbase = (Vnom * Vnom) / Sbase
+        Ybase = 1.0 / Zbase
 
-    rate = np.round(Imax * Vnom * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
+        R: float = np.round(r_ohm_total / Zbase, 6)
+        X: float = np.round(x_ohm_total / Zbase, 6)
+        B: float = np.round(b_siemens_total / Ybase, 6)
+        rate: float = np.round(Imax * Vnom * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
 
-    return R, X, B, rate
+        return R, X, B, rate
+    else:
+        logger.add_error("Nominal voltage is zero", device_class="SequenceLineType")
+        return 1e-20, 1e-20, 0, 1e-20
 
 
 def get_line_impedances_with_b(r_ohm: float, x_ohm: float, b_us: float, length: float,
-                               Imax: float, Sbase: float, Vnom: float) -> Tuple[float, float, float, float]:
+                               Imax: float, Sbase: float, Vnom: float,
+                               logger: Logger = Logger()) -> Tuple[float, float, float, float]:
     """
     Fill R, X, B from not-in-per-unit parameters
     :param r_ohm: Resistance per km in OHM/km
@@ -56,16 +68,20 @@ def get_line_impedances_with_b(r_ohm: float, x_ohm: float, b_us: float, length:
     x_ohm_total = x_ohm * length
     b_siemens_total = (b_us * 1e-6) * length
 
-    Zbase = (Vnom * Vnom) / Sbase
-    Ybase = 1.0 / Zbase
+    if Vnom > 0:
+        Zbase = (Vnom * Vnom) / Sbase
+        Ybase = 1.0 / Zbase
 
-    R = np.round(r_ohm_total / Zbase, 6)
-    X = np.round(x_ohm_total / Zbase, 6)
-    B = np.round(b_siemens_total / Ybase, 6)
+        R: float = np.round(r_ohm_total / Zbase, 6)
+        X: float = np.round(x_ohm_total / Zbase, 6)
+        B: float = np.round(b_siemens_total / Ybase, 6)
+        rate: float = np.round(Imax * Vnom * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
 
-    rate = np.round(Imax * Vnom * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
+        return R, X, B, rate
+    else:
+        logger.add_error("Nominal voltage is zero", device_class="SequenceLineType")
 
-    return R, X, B, rate
+        return 1e-20, 1e-20, 0, 1e-20
 
 
 class SequenceLineType(EditableDevice):
@@ -139,7 +155,8 @@ def __init__(self, name='SequenceLine', idtag=None, Imax=1, Vnom=1,
                       definition='Use conductance? else the susceptance is used')
         self.register(key='n_circuits', units='', tpe=int, definition='number of circuits')
 
-    def get_values(self, Sbase: float, freq: float, length: float, line_Vnom: float, ):
+    def get_values(self, Sbase: float, freq: float, length: float, line_Vnom: float,
+                   logger: Logger = Logger()):
         """
         Get the per-unit values
         :param Sbase: Base power (MVA, always use 100MVA)
@@ -153,24 +170,38 @@ def get_values(self, Sbase: float, freq: float, length: float, line_Vnom: float,
             R, X, B, rate = get_line_impedances_with_c(r_ohm=self.R,
                                                        x_ohm=self.X,
                                                        c_nf=self.Cnf,
-                                                       length=length, Imax=self.Imax,
-                                                       freq=freq, Sbase=Sbase, Vnom=line_Vnom)
+                                                       length=length,
+                                                       Imax=self.Imax,
+                                                       freq=freq,
+                                                       Sbase=Sbase,
+                                                       Vnom=line_Vnom,
+                                                       logger=logger)
+
             R0, X0, B0, _ = get_line_impedances_with_c(r_ohm=self.R0,
                                                        x_ohm=self.X0,
                                                        c_nf=self.Cnf0,
-                                                       length=length, Imax=self.Imax,
-                                                       freq=freq, Sbase=Sbase, Vnom=line_Vnom)
+                                                       length=length,
+                                                       Imax=self.Imax,
+                                                       freq=freq,
+                                                       Sbase=Sbase,
+                                                       Vnom=line_Vnom,
+                                                       logger=logger)
         else:
             R, X, B, rate = get_line_impedances_with_b(r_ohm=self.R,
                                                        x_ohm=self.X,
                                                        b_us=self.B,
-                                                       length=length, Imax=self.Imax,
-                                                       Sbase=Sbase, Vnom=line_Vnom)
+                                                       length=length,
+                                                       Imax=self.Imax,
+                                                       Sbase=Sbase,
+                                                       Vnom=line_Vnom)
+
             R0, X0, B0, _ = get_line_impedances_with_b(r_ohm=self.R0,
                                                        x_ohm=self.X0,
                                                        b_us=self.B0,
-                                                       length=length, Imax=self.Imax,
-                                                       Sbase=Sbase, Vnom=line_Vnom)
+                                                       length=length,
+                                                       Imax=self.Imax,
+                                                       Sbase=Sbase,
+                                                       Vnom=line_Vnom)
 
         return R, X, B, R0, X0, B0, rate
 
@@ -227,4 +258,4 @@ def get_ysh_nabc(self) -> AdmittanceMatrix:
         adm.phB = 1
         adm.phC = 1
 
-        return adm
+        return adm

src/VeraGridEngine/Devices/Branches/tap_changer.py

@@ -56,7 +56,7 @@ def __init__(self,
         self._asymmetry_angle = float(asymmetry_angle)
 
         # total number of positions
-        self._total_positions = int(total_positions)
+        self._total_positions = int(total_positions) if total_positions > 0 else 1
 
         # voltage increment in p.u.
         self._dV = float(dV)
@@ -102,15 +102,6 @@ def dV(self, dV: float) -> None:
         self._dV = float(dV)
         self.recalc()
 
-    @property
-    def neutral_position(self) -> int:
-        return self._neutral_position
-
-    @neutral_position.setter
-    def neutral_position(self, neutral_position: int) -> None:
-        self._neutral_position = int(neutral_position)
-        self.recalc()
-
     @property
     def normal_position(self) -> int:
         return self._normal_position
@@ -249,7 +240,7 @@ def parse(self, data: Dict[str, Union[str, float]], logger: Logger = Logger()) -
         self.tc_type = TapChangerTypes(data.get("type", TapChangerTypes.NoRegulation.value))
         self._negative_low = data.get("negative_low", False)
 
-        # parse the impedance corerction factors
+        # parse the impedance correction factors
 
         _k_re_array = data.get("impedance_correction_real", None)
         if _k_re_array is not None:

src/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 @@ def get_Pf_at(self, t: int | None) -> float:
         """
         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:
         """

src/VeraGridEngine/Devices/Injections/static_generator.py

@@ -9,11 +9,11 @@
 
 
 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 @@ def __init__(self, name='StaticGen', idtag=None, code='', P=0.0, Q=0.0, active=T
                             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

src/VeraGridEngine/Devices/Parents/branch_parent.py

@@ -497,6 +497,18 @@ def get_sorted_buses_voltages(self):
         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