VeraGridEngine 5.6.14__tar.gz → 5.6.17__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.6.14
+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.14 → 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.14 → 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.14 → 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.14 → 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.14 → veragridengine-5.6.17}/VeraGridEngine/IO/iidm/iidm_parser.py

@@ -26,6 +26,7 @@ from VeraGridEngine.IO.iidm.devices.iidm_circuit import IidmCircuit
     https://powsybl.readthedocs.io/projects/powsybl-core/en/stable/grid_model/network_subnetwork.html
 """
 
+
 def strip_ns(tag: str) -> str:
     """
 
@@ -84,7 +85,7 @@ def parse_xiidm_file(file_path: str) -> IidmCircuit:
                 _id=elem.attrib.get("id", ""),
                 area_number=elem.attrib.get("areaNumber", -1),
                 status=elem.attrib.get("status", ""),
-                nodes=[int(e) for e in elem.attrib.get("nodes", []).split(",")],
+                nodes=[int(e) for e in elem.attrib.get("nodes", "").split(",")],
             ))
 
         elif tag == "generator":
@@ -183,11 +184,9 @@ def parse_xiidm_file(file_path: str) -> IidmCircuit:
 
 
 if __name__ == "__main__":
-
-
-
     # fname = "/home/santi/Documentos/Git/GitHub/RTE7000/2021/01/01/recollement-auto-20210101-0000-enrichi.xiidm"
-    fname = "/home/santi/Documentos/Git/GitHub/RTE7000/2021/01/01/recollement-auto-20210101-0000-enrichi.xiidm.bz2"
+    # fname = "/home/santi/Documentos/Git/GitHub/RTE7000/2021/01/01/recollement-auto-20210101-0000-enrichi.xiidm.bz2"
+    fname = "/Users/santi/Git/eRoots/VeraGrid/src/tests/data/grids/ucte/network.xiidm"
 
     # import pypowsybl as pp
     # grid = pp.network.load(fname)
@@ -196,4 +195,3 @@ if __name__ == "__main__":
     iidm_circuit = parse_xiidm_file(fname)
 
     print()
-

{veragridengine-5.6.14 → 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.14 → veragridengine-5.6.17}/VeraGridEngine/IO/ucte/devices/ucte_comment.py

@@ -8,4 +8,4 @@ class UcteComment:
         self.content = ""
 
     def parse(self, line):
-        self.content = line.strip()
+        self.content = line.strip()

veragridengine-5.6.17/VeraGridEngine/IO/ucte/devices/ucte_exchange_power.py

@@ -0,0 +1,54 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# 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 VeraGridEngine.IO.ucte.devices.ucte_base import sub_str, sub_float, try_float
+from VeraGridEngine.basic_structures import Logger
+
+
+class UcteExchangePower:
+    """
+    UcteExchangePower
+    """
+    def __init__(self):
+        self.country1 = ""  # 0-1: Country 1 (ISO code)
+        self.country2 = ""  # 3-4: Country 2 (ISO code)
+        self.active_power = 0.0  # 6-12: Scheduled active power exchange (MW)
+        self.comments = ""  # 14-25: Optional comments
+
+    def parse(self, line, logger: Logger):
+        """
+
+        :param line:
+        :param logger:
+        :return:
+        """
+
+        device = "Exchange Power"
+
+        if len(line) == 27:
+            self.country1 = sub_str(line, 0, 2, device, "country1", logger)
+            self.country2 = sub_str(line, 3, 5, device, "country2", logger)
+            self.active_power = sub_float(line, 6, 13, device, "active_power", logger)
+            self.comments = sub_str(line, 14, 26, device, "comments", logger)
+
+        else:
+
+            logger.add_warning("Non canonical line length",
+                               device_class=device,
+                               value=len(line),
+                               expected_value=27)
+
+            chunks = line.split()
+
+            if len(chunks) >= 1:
+                self.country1 = chunks[0]
+
+            if len(chunks) >= 2:
+                self.country2 = chunks[1]
+
+            if len(chunks) >= 3:
+                self.active_power = try_float(chunks[3], device, "active_power", logger)
+
+            if len(chunks) >= 4:
+                self.comments = chunks[4]

{veragridengine-5.6.14 → veragridengine-5.6.17}/VeraGridEngine/IO/ucte/devices/ucte_line.py

@@ -80,40 +80,33 @@ class UcteLine:
 
             chunks = line.split()
 
-            if len(chunks) >= 9:
-
+            if len(chunks) >= 1:
                 self.node1 = chunks[0].strip()
+
+            if len(chunks) >= 2:
                 self.node2 = chunks[1].strip()
+
+            if len(chunks) >= 3:
                 self.order_code = chunks[2].strip()
+
+            if len(chunks) >= 4:
                 self.status = try_int(chunks[3].strip(), device, "status", logger)
+
+            if len(chunks) >= 5:
                 self.resistance = try_float(chunks[4].strip(), device, "resistance", logger)
+
+            if len(chunks) >= 6:
                 self.reactance = try_float(chunks[5].strip(), device, "reactance", logger)
+
+            if len(chunks) >= 7:
                 self.susceptance = try_float(chunks[6].strip(), device, "susceptance", logger)
-                self.current_limit = try_float(chunks[7].strip(), device, "current_limit", logger, 9999.0)
-                self.name = chunks[8].strip()
 
-            elif len(chunks) == 8:
+            if len(chunks) >= 8:
+                self.current_limit = try_float(chunks[7].strip(), device, "current_limit", logger,
+                                               9999.0)
 
-                self.node1 = chunks[0].strip()
-                self.node2 = chunks[1].strip()
-                self.order_code = chunks[2].strip()
-                self.status = try_int(chunks[3].strip(), device, "status", logger)
-                self.resistance = try_float(chunks[4].strip(), device, "resistance", logger)
-                self.reactance = try_float(chunks[5].strip(), device, "reactance", logger)
-                self.susceptance = try_float(chunks[6].strip(), device, "susceptance", logger)
-                self.current_limit = try_float(chunks[7].strip(), device, "current_limit", logger, 9999.0)
-                self.name = f"{self.node1}_{self.node2}_{self.order_code}"
-
-                logger.add_warning("Incorrect number of parameters",
-                                   device_class=device,
-                                   value=len(chunks),
-                                   expected_value=9)
-
-            else:
-                logger.add_error("Incorrect number of parameters",
-                                 device_class=device,
-                                 value=len(chunks),
-                                 expected_value=9)
+            if len(chunks) >= 9:
+                self.name = chunks[8].strip()
 
         if self.current_limit < 0:
             self.current_limit = 9999.0