GridCalEngine 5.3.9__tar.gz → 5.3.11__tar.gz

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/Branches/__init__.py

@@ -17,7 +17,7 @@ from GridCalEngine.Devices.Branches.winding import Winding
 from GridCalEngine.Devices.Branches.wire import Wire
 from GridCalEngine.Devices.Branches.tap_changer import TapChanger
 from GridCalEngine.Devices.Branches.transformer_type import TransformerType
-from GridCalEngine.Devices.Branches.overhead_line_type import OverheadLineType, WireInTower
+from GridCalEngine.Devices.Branches.overhead_line_type import OverheadLineType, WireInTower, ListOfWires
 from GridCalEngine.Devices.Branches.sequence_line_type import SequenceLineType
 from GridCalEngine.Devices.Branches.underground_line_type import UndergroundLineType
 from GridCalEngine.Devices.Branches.line_locations import LineLocations, LineLocation

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/Branches/line.py

@@ -393,8 +393,29 @@ class Line(BranchParent):
         :param logger: Logger
         """
 
-        if type(obj) in [OverheadLineType, UndergroundLineType, SequenceLineType]:
+        if isinstance(obj, OverheadLineType):
+            (self.R, self.X, self.B,
+             self.R0, self.X0, self.B0,
+             self.rate) = obj.get_values(Sbase=Sbase,  length=self.length)
+
+            if self.template is not None:
+                if obj != self.template:
+                    self.template = obj
+            else:
+                self.template = obj
+
+        elif isinstance(obj, UndergroundLineType):
+            (self.R, self.X, self.B,
+             self.R0, self.X0, self.B0,
+             self.rate) = obj.get_values(Sbase=Sbase,  length=self.length)
+
+            if self.template is not None:
+                if obj != self.template:
+                    self.template = obj
+            else:
+                self.template = obj
 
+        elif isinstance(obj, SequenceLineType):
             (self.R, self.X, self.B,
              self.R0, self.X0, self.B0,
              self.rate) = obj.get_values(Sbase=Sbase,

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/Branches/overhead_line_type.py

@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
 
-from typing import List
+from typing import List, Dict
 import numpy as np
 from numpy import pi, log, sqrt
 from matplotlib import pyplot as plt
@@ -12,6 +12,7 @@ from matplotlib import pyplot as plt
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
 from GridCalEngine.Devices.Branches.wire import Wire
+from GridCalEngine.enumerations import SubObjectType
 
 """
 Equations source:
@@ -49,6 +50,72 @@ class WireInTower:
 
         self.device_type = DeviceType.WireDevice
 
+    def __eq__(self, other: "WireInTower"):
+
+        return (self.wire ==other.wire
+                and self.xpos == other.xpos
+                and self.ypos == other.ypos
+                and self.phase == other.phase
+                and self.name==other.name)
+
+    def to_dict(self) -> Dict[str, str | float | int]:
+        """
+
+        :return:
+        """
+        return {
+            "wire": self.wire.idtag,
+            "name": self.name,
+            "xpos": self.xpos,
+            "ypos": self.ypos,
+            "phase": self.phase,
+        }
+
+    def parse(self, data: Dict[str, str | float | int], wire_dict: dict[str, Wire]):
+        """
+
+        :param data:
+        :param wire_dict:
+        :return:
+        """
+        self.wire: Wire = wire_dict.get(data["wire"])
+        self.name: str = data["name"]
+        self.xpos: float = data["xpos"]
+        self.ypos: float = data["ypos"]
+        self.phase: int = data["phase"]
+
+class ListOfWires:
+
+    def __init__(self):
+        self.data: List[WireInTower] = list()
+
+    def append(self, elm: WireInTower):
+        self.data.append(elm)
+
+    def to_list(self):
+
+        return [e.to_dict() for e in self.data]
+
+    def parse(self, data: List[Dict[str, str | float | int]], wire_dict: dict[str, Wire]):
+
+        for entry in data:
+            elm = WireInTower( wire_dict.get(entry["wire"]),
+                               entry["xpos"],
+                               entry["ypos"],
+                               entry["phase"])
+            elm.parse(entry, wire_dict)
+            self.append(elm)
+
+    def __eq__(self, other: "ListOfWires"):
+
+        if len(self.data) != len(other.data):
+            return False
+
+        for elm, other_elm in zip(self.data, other.data):
+            if elm != other_elm:
+                return False
+
+        return True
 
 class OverheadLineType(EditableDevice):
 
@@ -64,7 +131,7 @@ class OverheadLineType(EditableDevice):
                                 device_type=DeviceType.OverheadLineTypeDevice)
 
         # list of wires in the tower
-        self.wires_in_tower: List[WireInTower] = list()
+        self.wires_in_tower: ListOfWires = ListOfWires()
 
         self.Vnom = 1.0
 
@@ -120,6 +187,9 @@ class OverheadLineType(EditableDevice):
         self.register(key='Imax', units='kA', tpe=float, definition='Current rating of the tower', old_names=['rating'])
         self.register(key='Vnom', units='kV', tpe=float, definition='Voltage rating of the line')
 
+        self.register(key='wires_in_tower', units='', tpe=SubObjectType.ListOfWires, definition='List of wires',
+                      editable=False, display=False)
+
     def add_wire_relationship(self, wire: Wire, xpos: float = 0.0, ypos: float = 0.0, phase: int = 1):
         """
         Wire in a tower
@@ -176,12 +246,12 @@ class OverheadLineType(EditableDevice):
             fig = plt.Figure(figsize=(12, 6))
             ax = fig.add_subplot(1, 1, 1)
 
-        n = len(self.wires_in_tower)
+        n = len(self.wires_in_tower.data)
 
         if n > 0:
             x = np.zeros(n)
             y = np.zeros(n)
-            for i, wire_tower in enumerate(self.wires_in_tower):
+            for i, wire_tower in enumerate(self.wires_in_tower.data):
                 x[i] = wire_tower.xpos
                 y[i] = wire_tower.ypos
 
@@ -206,7 +276,7 @@ class OverheadLineType(EditableDevice):
 
         all_y_zero = True
         phases = set()
-        for i, wire_i in enumerate(self.wires_in_tower):
+        for i, wire_i in enumerate(self.wires_in_tower.data):
 
             phases.add(wire_i.phase)
 
@@ -217,7 +287,7 @@ class OverheadLineType(EditableDevice):
                 logger.add('The wires' + wire_i.name + '(' + str(i) + ') has GRM=0 which is impossible.')
                 return False
 
-            for j, wire_j in enumerate(self.wires_in_tower):
+            for j, wire_j in enumerate(self.wires_in_tower.data):
 
                 if i != j:
                     if wire_i.xpos == wire_j.xpos and wire_i.ypos == wire_j.ypos:
@@ -244,7 +314,7 @@ class OverheadLineType(EditableDevice):
         :return: max current (I) of the tower in A
         """
         r = 0
-        for wit in self.wires_in_tower:
+        for wit in self.wires_in_tower.data:
             r += wit.wire.max_current
 
         return r
@@ -263,14 +333,14 @@ class OverheadLineType(EditableDevice):
              self.z_phases_abcn,
              self.z_abc,
              self.z_phases_abc,
-             self.z_seq) = calc_z_matrix(self.wires_in_tower, f=self.frequency, rho=self.earth_resistivity)
+             self.z_seq) = calc_z_matrix(self.wires_in_tower.data, f=self.frequency, rho=self.earth_resistivity)
 
             # Admittances
             (self.y_abcn,
              self.y_phases_abcn,
              self.y_abc,
              self.y_phases_abc,
-             self.y_seq) = calc_y_matrix(self.wires_in_tower, f=self.frequency, rho=self.earth_resistivity)
+             self.y_seq) = calc_y_matrix(self.wires_in_tower.data, f=self.frequency, rho=self.earth_resistivity)
 
             # compute the tower rating in kA
             self.Imax = self.compute_rating()
@@ -291,9 +361,9 @@ class OverheadLineType(EditableDevice):
         :param wire:
         :return:
         """
-        n = len(self.wires_in_tower)
+        n = len(self.wires_in_tower.data)
         for i in range(n - 1, -1, -1):
-            if self.wires_in_tower[i].wire.name == wire.name:
+            if self.wires_in_tower.data[i].wire.name == wire.name:
                 return True
 
     def get_values(self, Sbase, length, round_vals: bool = False):

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/Branches/transformer_type.py

@@ -299,11 +299,11 @@ def get_impedances(VH_bus: float, VL_bus: float, Sn: float, HV: float, LV: float
 
         # rfe = Sn / (Pfe / 1000.0)
         rm = Sbase / (Pfe / 1000.0)
-        I0 = I0 * Sn / Sbase  # try?
+        I0 = I0 * Sn / Sbase
         zm = 1.0 / (I0 / 100.0)
 
-        inside_sqrt = (-zm ** 2 * rm ** 2) / (zm ** 2 - rm ** 2)
-        if inside_sqrt > 0:
+        if zm < rm:  # only with this is possible to perform xm, otherwise we get div0 or sqrt(neg)
+            inside_sqrt = (-zm ** 2 * rm ** 2) / (zm ** 2 - rm ** 2)
             xm = sqrt(inside_sqrt)
         else:
             xm = 0.0

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/Branches/underground_line_type.py

@@ -50,7 +50,7 @@ class UndergroundLineType(EditableDevice):
         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')
 
-    def get_values(self, Sbase, length):
+    def get_values(self, Sbase: float, length: float):
         """
         Get the per-unit values
         :param Sbase: Base power (MVA, always use 100MVA)

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/Parents/controllable_branch_parent.py

@@ -241,7 +241,7 @@ class ControllableBranchParent(BranchParent):
                                  'is expected for transformers0% for lines.')
 
         self.register(key='tap_changer', units='', tpe=SubObjectType.TapChanger, definition='Tap changer object',
-                      editable=False)
+                      editable=False, display=False)
 
         self.register(key='tap_module', units='', tpe=float, definition='Tap changer module, it a value close to 1.0',
                       profile_name='tap_module_prof', old_names=['tap', 'm'])

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/assets.py

@@ -2603,7 +2603,7 @@ class Assets:
         :param obj: Wire object
         """
         for tower in self._overhead_line_types:
-            for elm in tower.wires_in_tower:
+            for elm in tower.wires_in_tower.data:
                 if elm.template == obj:
                     elm.template = None
         try:

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/multi_circuit.py

@@ -858,27 +858,6 @@ class MultiCircuit(Assets):
             elm.P *= factor
             elm.Q *= factor
 
-    def get_used_templates(self):
-        """
-        Get a list of the used templates in the objects
-        :return: list
-        """
-        val = set()
-
-        branches = self.get_branches()
-
-        for branch in branches:
-            if hasattr(branch, 'template'):
-                obj = getattr(branch, 'template')
-                val.add(obj)
-
-                # if it is a tower, add the wire templates too
-                if obj.device_type == DeviceType.OverheadLineTypeDevice:
-                    for wire in obj.wires_in_tower:
-                        val.add(wire)
-
-        return list(val)
-
     def get_automatic_precision(self):
         """
         Get the precision that simulates correctly the power flow

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Devices/types.py

@@ -2,6 +2,8 @@
 # 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 typing import Dict, List, Any
+import pandas as pd
 from GridCalEngine.Devices.Aggregation import *
 from GridCalEngine.Devices.Associations import *
 from GridCalEngine.Devices.Branches import *
@@ -113,3 +115,6 @@ ALL_DEV_TYPES = Union[
 CONNECTION_TYPE = Union[ConnectivityNode, Bus, None]
 
 ASSOCIATION_TYPES = Union[Fuel, Technology, EmissionGas]
+
+# this is the data type of the GridCal Json
+GRIDCAL_FILE_TYPE = Dict[str, Union[str, float, pd.DataFrame, Dict[str, Any], List[Dict[str, Any]]]]

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/IO/file_handler.py

@@ -38,7 +38,7 @@ from GridCalEngine.IO.gridcal.sqlite_interface import save_data_frames_to_sqlite
 from GridCalEngine.IO.gridcal.h5_interface import save_h5, open_h5
 from GridCalEngine.IO.raw.rawx_parser_writer import parse_rawx, write_rawx
 from GridCalEngine.IO.others.pypsa_parser import parse_pypsa_netcdf, parse_pypsa_hdf5
-from GridCalEngine.IO.others.pandapower_parser import is_pandapower_file, Panda2GridCal
+from GridCalEngine.IO.others.pandapower_parser import Panda2GridCal
 from GridCalEngine.IO.cim.cgmes.cgmes_enums import cgmesProfile
 from GridCalEngine.IO.ucte.devices.ucte_circuit import UcteCircuit
 from GridCalEngine.IO.ucte.ucte_to_gridcal import convert_ucte_to_gridcal
@@ -431,7 +431,7 @@ class FileOpen:
                 elif file_extension.lower() == '.p':
                     self.circuit = Panda2GridCal(self.file_name, self.logger).get_multicircuit()
 
-                elif file_extension.lower() == '.uct' or file_extension.lower() == '.uct2':
+                elif file_extension.lower() == '.uct' or file_extension.lower() == '.ucte':
                     ucte_grid = UcteCircuit()
                     ucte_grid.parse_file(files=[self.file_name], logger=self.logger)
                     self.circuit = convert_ucte_to_gridcal(ucte_grid=ucte_grid, logger=self.logger)

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/IO/gridcal/pack_unpack.py

@@ -14,7 +14,7 @@ from GridCalEngine.Devices.multi_circuit import MultiCircuit
 import GridCalEngine.Devices as dev
 from GridCalEngine.Devices.Parents.editable_device import GCProp
 from GridCalEngine.Devices.profile import Profile
-from GridCalEngine.Devices.types import ALL_DEV_TYPES
+from GridCalEngine.Devices.types import ALL_DEV_TYPES, GRIDCAL_FILE_TYPE
 from GridCalEngine.enumerations import (DiagramType, DeviceType, SubObjectType, TapPhaseControl, TapModuleControl,
                                         ContingencyOperationTypes)
 
@@ -218,7 +218,7 @@ def gather_model_as_data_frames(circuit: MultiCircuit, logger: Logger = Logger()
         # because each tower contains a reference to a number of wires, these relations need to be stored as well
         associations = list()
         for tower in circuit.overhead_line_types:
-            for wire in tower.wires_in_tower:
+            for wire in tower.wires_in_tower.data:
                 associations.append([tower.name, wire.name, wire.xpos, wire.ypos, wire.phase])
 
         dfs['tower_wires'] = pd.DataFrame(data=associations,
@@ -399,6 +399,9 @@ def gridcal_object_to_json(elm: ALL_DEV_TYPES) -> Dict[str, str]:
         elif prop.tpe == SubObjectType.LineLocations:
             data[name] = obj.to_list()
 
+        elif prop.tpe == SubObjectType.ListOfWires:
+            data[name] = obj.to_list()
+
         elif prop.tpe == SubObjectType.TapChanger:
             data[name] = obj.to_dict()
 
@@ -1096,6 +1099,13 @@ def parse_object_type_from_json(template_elm: ALL_DEV_TYPES,
                                     locations_obj: dev.LineLocations = elm.get_snapshot_value(prop=gc_prop)
                                     locations_obj.parse(property_value)
 
+                                elif gc_prop.tpe == SubObjectType.ListOfWires:
+
+                                    # get the line locations object and fill it with the json data
+                                    list_of_wires: dev.ListOfWires = elm.get_snapshot_value(prop=gc_prop)
+                                    list_of_wires.parse(data=property_value,
+                                                        wire_dict=elements_dict_by_type[DeviceType.WireDevice])
+
                                 elif gc_prop.tpe == SubObjectType.TapChanger:
 
                                     # get the line locations object and fill it with the json data
@@ -1248,7 +1258,7 @@ def handle_legacy_jsons(model_data: Dict[str, List],
                                 value=f"{generator.name} -> {emission.name} at {rate}")
 
 
-def parse_gridcal_data(data: Dict[str, Union[str, float, pd.DataFrame, Dict[str, Any], List[Dict[str, Any]]]],
+def parse_gridcal_data(data: GRIDCAL_FILE_TYPE,
                        previous_circuit: Union[MultiCircuit, None] = None,
                        text_func: Union[Callable, None] = None,
                        progress_func: Union[Callable, None] = None,

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/IO/gridcal/zip_interface.py

@@ -10,7 +10,8 @@ import chardet
 import pandas as pd
 import zipfile
 from warnings import warn
-from typing import List, Dict, Union, Callable
+from typing import List, Dict, Union, Callable, Tuple, Any
+from GridCalEngine.Devices.types import GRIDCAL_FILE_TYPE
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.IO.gridcal.generic_io_functions import parse_config_df, CustomJSONizer
 from GridCalEngine.Simulations.results_template import DriverToSave
@@ -269,7 +270,7 @@ def read_data_frame_from_zip(file_pointer,
 def get_frames_from_zip(file_name_zip: str,
                         text_func: Union[None, Callable[[str], None]] = None,
                         progress_func: Union[None, Callable[[float], None]] = None,
-                        logger=Logger()):
+                        logger=Logger()) -> Tuple[GRIDCAL_FILE_TYPE, Dict[str, Any]]:
     """
     Open the csv files from a zip file
     :param file_name_zip: name of the zip file

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/IO/raw/devices/bus.py

@@ -26,6 +26,8 @@ class RawBus(RawObject):
         self.NVLO = 0.95
         self.EVHI = 1.1
         self.EVLO = 0.9
+        self.GL = 0.0
+        self.BL = 0.0
 
         self.register_property(property_name="I",
                                rawx_key="ibus",
@@ -139,8 +141,8 @@ class RawBus(RawObject):
             dta = np.zeros(13, dtype=object)
             dta[0:n] = data[0]
 
-            self.I, self.NAME, self.BASKV, self.IDE, self.AREA, self.ZONE, \
-                self.OWNER, self.VM, self.VA, self.NVHI, self.NVLO, self.EVHI, self.EVLO = dta
+            (self.I, self.NAME, self.BASKV, self.IDE, self.AREA, self.ZONE,
+             self.OWNER, self.VM, self.VA, self.NVHI, self.NVLO, self.EVHI, self.EVLO) = dta
 
         elif version == 32:
 
@@ -148,8 +150,8 @@ class RawBus(RawObject):
 
         elif version in [29, 30]:
             # I, 'NAME', BASKV, IDE, GL, BL, AREA, ZONE, VM, VA, OWNER
-            self.I, self.NAME, self.BASKV, self.IDE, self.GL, self.BL, \
-                self.AREA, self.ZONE, self.VM, self.VA, self.OWNER = data[0]
+            (self.I, self.NAME, self.BASKV, self.IDE, self.GL, self.BL,
+             self.AREA, self.ZONE, self.VM, self.VA, self.OWNER) = data[0]
 
 
         else:
@@ -161,23 +163,6 @@ class RawBus(RawObject):
         :param version: supported version
         :return:
         """
-        # if version >= 33:
-        #
-        #     return self.format_raw_line(["I", "NAME", "BASKV", "IDE", "AREA", "ZONE",
-        #                                  "OWNER", "VM", "VA", "NVHI", "NVLO", "EVHI", "EVLO"])
-        #
-        # elif version == 32:
-        #
-        #     return self.format_raw_line(["I", "NAME", "BASKV", "IDE", "AREA", "ZONE",
-        #                                  "OWNER", "VM", "VA"])
-        #
-        # elif version in [29, 30]:
-        #
-        #     return self.format_raw_line(["I", "NAME", "BASKV", "IDE", "GL", "BL",
-        #                                  "AREA", "ZONE", "VM", "VA", "OWNER"])
-        #
-        # else:
-        #     raise Exception('Bus not implemented for version', str(version))
 
         if version >= 33:
             return self.format_raw_line(["I", "NAME", "BASKV", "IDE", "AREA", "ZONE",
@@ -197,5 +182,3 @@ class RawBus(RawObject):
 
     def get_id(self) -> str:
         return str(self.I)
-
-

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/IO/raw/devices/psse_object.py

@@ -7,6 +7,7 @@ import uuid as uuidlib
 from typing import List, Dict, TypeVar
 from GridCalEngine.IO.base.units import Unit
 from GridCalEngine.IO.raw.devices.psse_property import PsseProperty
+from GridCalEngine.basic_structures import Logger
 
 
 def uuid_from_seed(seed: str):
@@ -127,6 +128,7 @@ class RawObject:
         :param max_chars:
         :param min_value:
         :param max_value:
+        :param format_rule: some formatting rule
         """
         if hasattr(self, property_name):
             self.__registered_properties[property_name] = PsseProperty(property_name=property_name,

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/IO/raw/devices/transformer.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 typing import Tuple
+from typing import Tuple, List
 from GridCalEngine.IO.base.units import Unit
 from GridCalEngine.IO.raw.devices.psse_object import RawObject
 from GridCalEngine.basic_structures import Logger
@@ -661,7 +661,7 @@ class RawTransformer(RawObject):
                                    max_value=1.0,
                                    format_rule=".4f")
 
-    def parse(self, data, version, logger: Logger):
+    def parse(self, data: List[List[float | int | str]], version: int, logger: Logger):
         """
 
         :param data:
@@ -674,8 +674,8 @@ class RawTransformer(RawObject):
         if version >= 34:
 
             # Line 1: for both types
-            self.I, self.J, self.K, self.CKT, self.CW, self.CZ, self.CM, self.MAG1, self.MAG2, self.NMETR, \
-                self.NAME, self.STAT, *var, self.VECGRP, self.ZCOD = data[0]
+            (self.I, self.J, self.K, self.CKT, self.CW, self.CZ, self.CM, self.MAG1, self.MAG2, self.NMETR,
+             self.NAME, self.STAT, *var, self.VECGRP, self.ZCOD) = data[0]
 
             if len(data) == 4:
                 self.windings = 2
@@ -1247,13 +1247,12 @@ class RawTransformer(RawObject):
             # Shunt impedance (leakage)
             if Pfe > 0.0 and I0 > 0.0:
 
-                # rfe = Sn / (Pfe / 1000.0)
                 rm = Sbase / (Pfe / 1000.0)
-                I0 = I0 * Sn / Sbase  # try?
+                I0 = I0 * Sn / Sbase
                 zm = 1.0 / (I0 / 100.0)
 
-                inside_sqrt = (-zm ** 2 * rm ** 2) / (zm ** 2 - rm ** 2)
-                if inside_sqrt > 0:
+                if zm < rm:  # only with this is possible to perform xm, otherwise we get div0 or sqrt(neg)
+                    inside_sqrt = (-zm ** 2 * rm ** 2) / (zm ** 2 - rm ** 2)
                     xm = np.sqrt(inside_sqrt)
                 else:
                     xm = 0.0

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/IO/raw/raw_parser_writer.py

@@ -221,6 +221,28 @@ def check_end_of_impedance_table(row: List[int | float | str]) -> bool:
     else:
         return False
 
+def is_valid(value: float | int | str):
+    return value is not None and isinstance(value, (int, float, str))
+
+def format_lines(data1: List[List[float | int | str]], logger: Logger) -> List[List[float | int | str]]:
+    """
+    Format PSSe lines
+    :param data1:
+    :param logger:
+    :return:
+    """
+    data = list()
+    for lst in data1:
+        sublist = list()
+        for val in lst:
+            if is_valid(val):
+                sublist.append(val)
+            else:
+                sublist.append(0)
+                logger.add_error("Invalid PSSe value", value=val)
+        data.append(sublist)
+
+    return data
 
 def read_raw(filename, text_func=None, progress_func=None, logger=Logger()) -> PsseCircuit:
     """
@@ -336,7 +358,7 @@ def read_raw(filename, text_func=None, progress_func=None, logger=Logger()) -> P
                 while l_count < len(lines):
 
                     # lines_per_object2 = lines_per_object
-                    data = list()
+                    data: List[List[float | int | str]] = list()
                     if key == 'transformer':
                         # as you know the PSS/e raw format is nuts, that is why for v29 (onwards probably)
                         # the transformers may have 4 or 5 lines to define them
@@ -364,8 +386,8 @@ def read_raw(filename, text_func=None, progress_func=None, logger=Logger()) -> P
                                 l_count += 1
 
                     elif key == 'impedance correction' and version >= 35:
-                        # since PSSe is nothing but a very questionable set of legacy sofwtare,
-                        # when we're dealing with impedance tables, the number of lines is unkown
+                        # since PSSe is nothing but a very questionable set of legacy software,
+                        # when we're dealing with impedance tables, the number of lines is unknown
                         # and determined by the termination criteria 0.0, 0.0, 0.0
                         done = False
                         while not done:
@@ -389,8 +411,9 @@ def read_raw(filename, text_func=None, progress_func=None, logger=Logger()) -> P
                     # data = [interpret_line(object_lines[k]) for k in range(lines_per_object)]
 
                     # pass the data to the according object to assign it to the matching variables
+                    data2 = format_lines(data1=data, logger=logger)
                     obj = ObjectT()
-                    obj.parse(data, version, logger)
+                    obj.parse(data2, version, logger)
                     objects_list.append(obj)
 
                     if progress_func is not None:

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/IO/raw/raw_to_gridcal.py

@@ -244,7 +244,7 @@ def get_gridcal_shunt_switched(
                                 vset=vset,
                                 code=busnum_id,
                                 is_nonlinear=True,
-                                is_controlled=is_controlled,)
+                                is_controlled=is_controlled, )
 
     if psse_elm.SWREG > 0:
         if psse_elm.SWREG != psse_elm.I:
@@ -413,9 +413,7 @@ def get_gridcal_transformer(
                     tc_total_positions = psse_elm.NTP1
                     tc_neutral_position = np.floor(psse_elm.NTP1 / 2)
                     tc_normal_position = np.floor(psse_elm.NTP1 / 2)
-                    tc_dV = (psse_elm.VMA1 - psse_elm.VMI1) / (
-                            psse_elm.NTP1 - 1) \
-                        if (psse_elm.NTP1 - 1) > 0 else 0.01
+                    tc_dV = (psse_elm.VMA1 - psse_elm.VMI1) / (psse_elm.NTP1 - 1) if (psse_elm.NTP1 - 1) > 0 else 0.01
                     distance_from_low = tap_module - psse_elm.VMI1
                     tc_tap_pos = distance_from_low / tc_dV if tc_dV != 0 else 0.5
             elif psse_elm.VMA2 != 0:
@@ -423,9 +421,7 @@ def get_gridcal_transformer(
                     tc_total_positions = psse_elm.NTP2
                     tc_neutral_position = np.floor(psse_elm.NTP2 / 2)
                     tc_normal_position = np.floor(psse_elm.NTP2 / 2)
-                    tc_dV = (psse_elm.VMA2 - psse_elm.VMI2) / (
-                            psse_elm.NTP2 - 1) \
-                        if (psse_elm.NTP2 - 1) > 0 else 0.01
+                    tc_dV = (psse_elm.VMA2 - psse_elm.VMI2) / (psse_elm.NTP2 - 1) if (psse_elm.NTP2 - 1) > 0 else 0.01
                     distance_from_low = tap_module - psse_elm.VMI2
                     tc_tap_pos = distance_from_low / tc_dV if tc_dV != 0 else 0.5
             else:
@@ -433,9 +429,7 @@ def get_gridcal_transformer(
                     tc_total_positions = psse_elm.NTP3
                     tc_neutral_position = np.floor(psse_elm.NTP3 / 2)
                     tc_normal_position = np.floor(psse_elm.NTP3 / 2)
-                    tc_dV = (psse_elm.VMA3 - psse_elm.VMI3) / (
-                            psse_elm.NTP3 - 1) \
-                        if (psse_elm.NTP3 - 1) > 0 else 0.01
+                    tc_dV = (psse_elm.VMA3 - psse_elm.VMI3) / (psse_elm.NTP3 - 1) if (psse_elm.NTP3 - 1) > 0 else 0.01
                     distance_from_low = tap_module - psse_elm.VMI3
                     tc_tap_pos = distance_from_low / tc_dV if tc_dV != 0 else 0.5
 
@@ -479,15 +473,18 @@ def get_gridcal_transformer(
             d_ang = psse_elm.RMA1 / ((psse_elm.NTP1 - 1) / 2)
             # ?: this value is set internally by set_tap_phase
             # tc_tap_position
-            tc_step = round(psse_elm.ANG1 / d_ang)
-            if tc_step - (psse_elm.ANG1 / d_ang) > 0.1:
-                logger.add_warning(
-                    device=psse_elm,
-                    device_class=psse_elm.class_name,
-                    msg="Tap changer is not on discrete step.",
-                    value=psse_elm.ANG1 / d_ang,
-                )
-            tc_tap_pos = tc_neutral_position + tc_step
+            if d_ang != 0.0:
+                tc_step = round(psse_elm.ANG1 / d_ang)
+                if tc_step - (psse_elm.ANG1 / d_ang) > 0.1:
+                    logger.add_warning(
+                        device=psse_elm,
+                        device_class=psse_elm.class_name,
+                        msg="Tap changer is not on discrete step.",
+                        value=psse_elm.ANG1 / d_ang,
+                    )
+                tc_tap_pos = tc_neutral_position + tc_step
+            else:
+                tc_step = 0
             # print()
             # corrected_phase = elm.tap_changer.set_tap_phase(elm.tap_phase)
             # elm.tap_phase = corrected_phase

{gridcalengine-5.3.9 → gridcalengine-5.3.11}/GridCalEngine/Simulations/Derivatives/ac_jacobian.py

@@ -314,7 +314,7 @@ def create_J_vc_csc(nbus: int, Yx: CxVec, Yp: IntVec, Yi: IntVec, V: CxVec,
     nnz_estimate = 5 * len(dS_dVm_x)
     J = CSC(nj, nj, nnz_estimate, False)
 
-    # Note: The row and column pointer of of dVm and dVa are the same as the one from Ybus
+    # Note: The row and column pointer of dVm and dVa are the same as the one from Ybus
     lookup_dP = make_lookup(nbus, idx_dP)
     lookup_dQ = make_lookup(nbus, idx_dQ)