VeraGridEngine 5.6.15__tar.gz → 5.6.17__tar.gz

{veragridengine-5.6.15 → veragridengine-5.6.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.6.15
+Version: 5.6.17
 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.15 → veragridengine-5.6.17}/VeraGridEngine/Devices/Branches/line.py

@@ -662,8 +662,16 @@ class Line(BranchParent):
 
         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 @@ class Line(BranchParent):
         :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
 

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/Devices/Branches/sequence_line_type.py

@@ -6,11 +6,18 @@ from typing import Tuple
 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 @@ class SequenceLineType(EditableDevice):
                       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 @@ class SequenceLineType(EditableDevice):
             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 @@ class SequenceLineType(EditableDevice):
         adm.phB = 1
         adm.phC = 1
 
-        return adm
+        return adm

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/Devices/Parents/editable_device.py

@@ -796,7 +796,7 @@ class EditableDevice:
                 # set the profile variable associated with the magnitude
                 setattr(self, self.properties_with_profile[magnitude], val2)
 
-    def create_profile(self, magnitude, index):
+    def create_profile(self, magnitude, index: pd.DatetimeIndex):
         """
         Create power profile based on index
         :param magnitude: name of the property
@@ -810,6 +810,8 @@ class EditableDevice:
 
         if prof is None:
             print("The profile is none, this is a bug!")
+        elif index is pd.NaT:
+            pass
         else:
             prof.create_sparse(size=len(index), default_value=snapshot_value)
 
@@ -823,7 +825,9 @@ class EditableDevice:
         :param index: Time series index (timestamps)
         :param set_profile_default_as_snapshot: set the bool default profile value as the snapshot
         """
-        if index is not None:
+        if index is None or index is pd.NaT:
+            raise Exception("ensure_profiles_exist: No index provided")
+        else:
             for magnitude, prof_attr in self.properties_with_profile.items():
 
                 # get the profile
@@ -847,9 +851,6 @@ class EditableDevice:
                     val = getattr(self, magnitude)
                     profile.default_value = val
 
-        else:
-            raise Exception("ensure_profiles_exist: No index provided")
-
     def delete_profiles(self):
         """
         Delete the object profiles (set all to None)

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/Devices/assets.py

@@ -449,10 +449,10 @@ class Assets:
         Return the number of buses
         :return: number
         """
-        if self._time_profile is not None:
-            return len(self._time_profile)
-        else:
+        if self._time_profile is None or self._time_profile is pd.NaT:
             return 0
+        else:
+            return len(self._time_profile)
 
     def get_time_array(self) -> pd.DatetimeIndex:
         """
@@ -478,10 +478,17 @@ class Assets:
         if isinstance(value, pd.DatetimeIndex):
             self._time_profile = value
         else:
-            try:
-                self._time_profile = pd.to_datetime(value)
-            except TypeError:
-                warnings.warn(f"Trying to set time profile with something else {type(value)}")
+            if value is None or value is pd.NaT:
+                if self._time_profile is None:
+                    # the time profile is None al ready
+                    pass
+                else:
+                    raise ValueError("Cannot set the time profile to None because it is already not None")
+            else:
+                try:
+                    self._time_profile = pd.to_datetime(value)
+                except TypeError:
+                    warnings.warn(f"Trying to set time profile with something else {type(value)}")
 
     def get_all_time_indices(self) -> IntVec:
         """
@@ -641,7 +648,7 @@ class Assets:
         """
         for elm in self.items():
             elm.delete_profiles()
-        self.time_profile = None
+        self._time_profile = None
 
     def resample_profiles(self, indices: IntVec):
         """
@@ -5822,7 +5829,6 @@ class Assets:
         """
         for elm in self.contingencies:
             if elm.device_idtag == obj.idtag:
-                print(elm)
                 self.delete_contingency(elm, del_group=delete_groups)
 
         for elm in self.remedial_actions:

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/IO/ucte/devices/ucte_base.py

@@ -43,7 +43,7 @@ def sub_float(line: str, a: int, b: int, device: str, prop_name: str, logger: Lo
         chunk = line[a:b].strip()
 
         if chunk == "":
-            logger.add_error(msg="Empty chunk",
+            logger.add_error(msg="Property not provided",
                              device=device,
                              device_property=prop_name,
                              value=line)
@@ -81,11 +81,21 @@ def try_int(val: str, device: str, prop_name: str, logger: Logger, fallback_valu
     try:
         return int(val)
     except ValueError as e:
-        logger.add_error(msg=str(e),
+
+        val2 = try_float(val=val,
                          device=device,
-                         device_property=prop_name,
-                         value=val)
-        return fallback_value
+                         prop_name=prop_name,
+                         logger=logger,
+                         fallback_value=0)
+
+        try:
+            return int(val2)
+        except ValueError as e:
+            logger.add_error(msg=str(e),
+                             device=device,
+                             device_property=prop_name,
+                             value=val)
+            return fallback_value
 
 
 def sub_int(line: str, a: int, b: int, device: str, prop_name: str, logger: Logger,
@@ -105,7 +115,7 @@ def sub_int(line: str, a: int, b: int, device: str, prop_name: str, logger: Logg
         chunk = line[a:b].strip()
 
         if chunk == "":
-            logger.add_error(msg="Empty chunk",
+            logger.add_error(msg="Property not provided",
                              device=device,
                              device_property=prop_name,
                              value=line)

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/IO/ucte/devices/ucte_node.py

@@ -52,22 +52,34 @@ def try_parse_voltage(val: str | float, name: str, logger: Logger) -> float:
 
     :return:
     """
-    try:
-        return float(val)
-    except ValueError:
-        val2 = UCTE_VOLTAGE_MAP.get(val, None)
-        if val2 is None:
+    val2 = UCTE_VOLTAGE_MAP.get(val, None)
+    if val2 is None:
+        try:
+            f = float(val)
+        except ValueError as e:
             logger.add_error('Could not parse UCTE voltage',
                              device=name, value=f"'{val}'")
             return 1.0
+
+        if f > 0.0:
+            logger.add_warning('UCTE Voltage was not provided as a value from the standard, but directly as a float',
+                               device=name,
+                               value=f"'{val}'")
+            return f
         else:
-            return val2
+            logger.add_error('Provided UCTE voltage is zero',
+                             device=name,
+                             value=f"'{val} -> {f}'")
+            return 1.0
+    else:
+        return val2
 
 
 class UcteNode:
     """
     UcteNode
     """
+
     def __init__(self):
 
         self.current_country = ""
@@ -148,7 +160,8 @@ class UcteNode:
             self.min_gen_mvar = sub_float(line, 81, 88, device, "min_gen_mvar", logger, -9999.0)
             self.max_gen_mvar = sub_float(line, 89, 96, device, "max_gen_mvar", logger, 9999.0)
             self.static_primary_control = sub_float(line, 97, 102, device, "static_primary_control", logger)
-            self.nominal_power_primary_control = sub_float(line, 103, 110, device, "nominal_power_primary_control", logger)
+            self.nominal_power_primary_control = sub_float(line, 103, 110, device, "nominal_power_primary_control",
+                                                           logger)
             self.short_circuit_power = sub_float(line, 111, 118, device, "short_circuit_power", logger)
             self.xr_ratio = sub_float(line, 119, 126, device, "xr_ratio", logger)
             self.plant_type = sub_str(line, 127, 128, device, "plant_type", logger)
@@ -162,7 +175,7 @@ class UcteNode:
             elif voltage_code == "":
                 logger.add_warning("Incorrect line formatting impede finding the voltage code",
                                    device_class=device,
-                                   value=line,)
+                                   value=line, )
 
             chunks = line.split()
 
@@ -209,7 +222,8 @@ class UcteNode:
                 self.static_primary_control = try_float(chunks[13], device, "static_primary_control", logger)
 
             if len(chunks) >= 15:
-                self.nominal_power_primary_control = try_float(chunks[14], device, "nominal_power_primary_control", logger)
+                self.nominal_power_primary_control = try_float(chunks[14], device, "nominal_power_primary_control",
+                                                               logger)
 
             if len(chunks) >= 16:
                 self.short_circuit_power = try_float(chunks[15], device, "short_circuit_power", logger)

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/IO/ucte/ucte_to_veragrid.py

@@ -12,11 +12,12 @@ from VeraGridEngine.enumerations import TapChangerTypes
 import VeraGridEngine.Devices as dev
 
 
-def parse_nodes(ucte_grid: UcteCircuit, grid: MultiCircuit) -> Dict[str, dev.Bus]:
+def parse_nodes(ucte_grid: UcteCircuit, grid: MultiCircuit, logger: Logger) -> Dict[str, dev.Bus]:
     """
 
     :param ucte_grid:
     :param grid:
+    :param logger:
     :return:
     """
     bus_dict: Dict[str, dev.Bus] = dict()
@@ -40,7 +41,7 @@ def parse_nodes(ucte_grid: UcteCircuit, grid: MultiCircuit) -> Dict[str, dev.Bus
     country_dict = dict()
 
     # create buses
-    for ucte_elm in ucte_grid.nodes:
+    for k, ucte_elm in enumerate(ucte_grid.nodes):
 
         if ucte_elm.current_country != "":
             country = country_dict.get(ucte_elm.current_country, None)
@@ -52,6 +53,15 @@ def parse_nodes(ucte_grid: UcteCircuit, grid: MultiCircuit) -> Dict[str, dev.Bus
         else:
             country = None
 
+        name = f"Bus {ucte_elm.node_code} {ucte_elm.geo_name}"
+
+        if ucte_elm.voltage <= 0:
+            logger.add_error("Bus nominal voltage is invalid",
+                             device_class="Bus",
+                             device=name,
+                             value=ucte_elm.voltage,
+                             expected_value=">0")
+
         elm = dev.Bus(
             name=ucte_elm.geo_name,
             code=ucte_elm.node_code,
@@ -136,6 +146,7 @@ def parse_lines(ucte_grid: UcteCircuit, grid: MultiCircuit, bus_dict: Dict[str,
                 Imax=ucte_elm.current_limit / 1000.0,  # A to kA
                 freq=grid.fBase,
                 Sbase=grid.Sbase,
+                logger=logger
             )
 
             grid.add_line(obj=elm, logger=logger)
@@ -262,7 +273,7 @@ def convert_ucte_to_veragrid(ucte_grid: UcteCircuit, logger: Logger) -> MultiCir
     grid.Sbase = 100.0
     grid.comments = ucte_grid.fuse_comments()
 
-    bus_dict: Dict[str, dev.Bus] = parse_nodes(ucte_grid=ucte_grid, grid=grid)
+    bus_dict: Dict[str, dev.Bus] = parse_nodes(ucte_grid=ucte_grid, grid=grid, logger=logger)
     parse_lines(ucte_grid=ucte_grid, grid=grid, bus_dict=bus_dict, logger=logger)
     parse_transformer(ucte_grid=ucte_grid, grid=grid, bus_dict=bus_dict, logger=logger)
     parse_exchange_power(ucte_grid=ucte_grid, grid=grid, bus_dict=bus_dict, logger=logger)
@@ -279,4 +290,4 @@ if __name__ == "__main__":
     g.parse_file([fname], logger)
     parser = convert_ucte_to_veragrid(g, logger)
 
-    print()
+    print()

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/IO/veragrid/pack_unpack.py

@@ -717,12 +717,12 @@ def parse_object_type_from_dataframe(
         elm.disable_auto_updates()
 
         # ensure the profiles existence
-        if time_profile is not None:
+        if time_profile is None or time_profile is pd.NaT:
+            nt = 0
+        else:
             nt = len(time_profile)
             if nt > 0:
                 elm.ensure_profiles_exist(index=time_profile)
-        else:
-            nt = 0
 
         # parse each property of the row
         for property_name_, property_value in row.items():

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/Simulations/OPF/Formulations/linear_opf_ts.py

@@ -758,14 +758,10 @@ def add_linear_simple_generation_formulation(local_t: Union[int, None],
     :param gen_data_t: GeneratorData structure
     :param gen_vars: GenerationVars structure
     :param prob: LpModel
-    :param unit_commitment: formulate unit commitment?
     :param ramp_constraints: formulate ramp constraints?
     :param consider_time_up_down: consider time up/down?
     :param area_spinning_reserve: area spinning reserve?
     :param skip_generation_limits: skip the generation limits?
-    :param vd: slack indices
-    :param nodal_capacity_active: nodal capacity active?
-    :param generation_expansion_planning: generation expansion plan?
     :param use_glsk_as_cost: if true, the GLSK values are used instead of the traditional costs
     :param logger: Logger object
     :return objective function

{veragridengine-5.6.15 → veragridengine-5.6.17}/VeraGridEngine/Simulations/OPF/opf_ts_results.py

@@ -8,11 +8,9 @@ from typing import Union, TYPE_CHECKING
 import numpy as np
 import pandas as pd
 from matplotlib import pyplot as plt
-import matplotlib.colors as plt_colors
 from VeraGridEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
 from VeraGridEngine.Simulations.results_table import ResultsTable
 from VeraGridEngine.Simulations.results_template import ResultsTemplate
-from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 from VeraGridEngine.basic_structures import IntVec, Vec, StrVec, CxMat, Mat, BoolVec
 from VeraGridEngine.enumerations import StudyResultsType, ResultTypes, DeviceType