GridCalEngine 5.3.10__tar.gz → 5.3.11__tar.gz

{gridcalengine-5.3.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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.10 → gridcalengine-5.3.11}/GridCalEngine/IO/gridcal/pack_unpack.py

@@ -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

{gridcalengine-5.3.10 → gridcalengine-5.3.11}/GridCalEngine/Simulations/PowerFlow/NumericalMethods/levenberg_marquadt_fx.py

@@ -45,7 +45,6 @@ def levenberg_marquardt_fx(problem: PfFormulationTemplate,
         # for instance there might be a single node that is a slack node
         return problem.get_solution(elapsed=time.time() - start, iterations=0)
 
-    normF = 100000
     update_jacobian = True
     iter_ = 0
     nu = 2.0

{gridcalengine-5.3.10 → gridcalengine-5.3.11}/GridCalEngine/Simulations/PowerFlow/NumericalMethods/powell_fx.py

@@ -27,7 +27,7 @@ def compute_beta(a: Vec, b: Vec, delta: float):
     c = a @ ba
     norm2_a = a @ a
     norm2_ba = ba @ ba
-    delta2_norm2a = (delta * delta - norm2_a)
+    delta2_norm2a = delta * delta - norm2_a
     if c <= 0.0:
         return (-c + np.sqrt(c * c + norm2_ba * delta2_norm2a)) / norm2_ba
     else:
@@ -93,27 +93,28 @@ def powell_fx(problem: PfFormulationTemplate,
 
     delta = trust
     f_error, converged, x, f = problem.update(x, update_controls=False)
-    J = mat_to_scipy(problem.Jacobian())
 
-    if J.shape[0] != J.shape[1]:
-        logger.add_error("Jacobian not square, check the controls!", "Powell")
+    if problem.converged:
         return problem.get_solution(elapsed=time.time() - start, iterations=0)
 
-    g = J.T @ f
+    else:
 
-    iteration = 0
-    error_evolution = np.zeros(max_iter + 1)
+        J = mat_to_scipy(problem.Jacobian())
 
-    # save the error evolution
-    error_evolution[iteration] = f_error
+        if J.shape[0] != J.shape[1]:
+            logger.add_error("Jacobian not square, check the controls!", "Powell")
+            return problem.get_solution(elapsed=time.time() - start, iterations=0)
 
-    if verbose > 0:
-        print(f'It {iteration}, error {f_error}, converged {converged}, x {x}, dx not computed yet')
+        g = J.T @ f
 
-    if problem.converged:
-        return problem.get_solution(elapsed=time.time() - start, iterations=iteration)
+        iteration = 0
+        error_evolution = np.zeros(max_iter + 1)
 
-    else:
+        # save the error evolution
+        error_evolution[iteration] = f_error
+
+        if verbose > 0:
+            print(f'It {iteration}, error {f_error}, converged {converged}, x {x}, dx not computed yet')
 
         while not converged and iteration < max_iter:
 

{gridcalengine-5.3.10 → gridcalengine-5.3.11}/GridCalEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # do not forget to keep a three-number version!!!
-__GridCalEngine_VERSION__ = "5.3.10"
+__GridCalEngine_VERSION__ = "5.3.11"
 
 url = 'https://github.com/SanPen/GridCal'
 

{gridcalengine-5.3.10 → gridcalengine-5.3.11}/GridCalEngine/enumerations.py

@@ -908,6 +908,7 @@ class SubObjectType(Enum):
     Array = "Array"
     ObjectsList = "ObjectsList"
     Associations = "AssociationsList"
+    ListOfWires = 'ListOfWires'
 
     def __str__(self) -> str:
         return str(self.value)

{gridcalengine-5.3.10 → gridcalengine-5.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GridCalEngine
-Version: 5.3.10
+Version: 5.3.11
 Summary: GridCal is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/GridCal
 Author: Santiago Peñate Vera et. Al.