GridCalEngine 5.3.20__tar.gz → 5.3.21__tar.gz

{gridcalengine-5.3.20 → gridcalengine-5.3.21}/GridCalEngine/Compilers/circuit_to_gslv.py

@@ -2381,54 +2381,56 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults") ->
     :param res: GSLV's PowerFlowResults instance
     :return: PowerFlowResults instance
     """
-    results = PowerFlowResults(n=grid.get_bus_number(),
-                               m=grid.get_branch_number_wo_hvdc(),
-                               n_hvdc=grid.get_hvdc_number(),
-                               n_vsc=grid.get_vsc_number(),
-                               n_gen=grid.get_generators_number(),
-                               n_batt=grid.get_batteries_number(),
-                               n_sh=grid.get_shunt_like_device_number(),
-                               bus_names=res.bus_names,
-                               branch_names=res.branch_names,
-                               hvdc_names=res.hvdc_names,
-                               vsc_names=grid.get_vsc_names(),
-                               gen_names=grid.get_generator_names(),
-                               batt_names=grid.get_battery_names(),
-                               sh_names=grid.get_shunt_like_devices_names(),
-                               bus_types=res.bus_types)
+    results = PowerFlowResults(
+        n=grid.get_bus_number(),
+        m=grid.get_branch_number_wo_hvdc(),
+        n_hvdc=grid.get_hvdc_number(),
+        n_vsc=grid.get_vsc_number(),
+        n_gen=grid.get_generators_number(),
+        n_batt=grid.get_batteries_number(),
+        n_sh=grid.get_shunt_like_device_number(),
+        bus_names=grid.get_bus_names(),
+        branch_names=grid.get_branch_names(add_switch=True),
+        hvdc_names=grid.get_hvdc_names(),
+        vsc_names=grid.get_vsc_names(),
+        gen_names=grid.get_generator_names(),
+        batt_names=grid.get_battery_names(),
+        sh_names=grid.get_shunt_like_devices_names(),
+        bus_types=np.ones(grid.get_bus_number(), dtype=int)
+    )
 
     results.voltage = res.voltage[0, :]
-    results.Sbus = res.Scalc[0, :]
+    results.Sbus = res.S[0, :]
     results.Sf = res.Sf[0, :]
     results.St = res.St[0, :]
-    results.loading = res.Loading[0, :]
-    results.losses = res.Losses[0, :]
+    results.loading = res.loading[0, :]
+    results.losses = res.losses[0, :]
     # results.Vbranch = res.Vbranch[0, :]
     # results.If = res.If[0, :]
     # results.It = res.It[0, :]
-    results.Beq = res.Beq[0, :]
+    # results.Beq = res.Beq[0, :]
     results.m = res.tap_module[0, :]
     results.tap_angle = res.tap_angle[0, :]
-    results.F = res.F
-    results.T = res.T
-    results.hvdc_F = res.hvdc_F
-    results.hvdc_T = res.hvdc_T
-    results.Pf_hvdc = res.hvdc_Pf[0, :]
-    results.Pt_hvdc = res.hvdc_Pt[0, :]
-    results.loading_hvdc = res.hvdc_loading[0, :]
-    results.losses_hvdc = res.hvdc_losses[0, :]
-    results.bus_area_indices = grid.get_bus_area_indices()
+    # results.F = res.F
+    # results.T = res.T
+    # results.hvdc_F = res.hvdc_F[0, :]
+    # results.hvdc_T = res.hvdc_T[0, :]
+    results.Pf_hvdc = res.Pf_hvdc[0, :]
+    results.Pt_hvdc = res.Pt_hvdc[0, :]
+    results.loading_hvdc = res.loading_hvdc[0, :]
+    results.losses_hvdc = res.losses_hvdc[0, :]
+    # results.bus_area_indices = grid.get_bus_area_indices()
     # results.area_names = [a.name for a in grid.areas]
     # results.bus_types = convert_bus_types(res.bus_types[0])  # this is a list of lists
 
-    for rep in res.stats[0]:
-        report = ConvergenceReport()
-        for i in range(len(rep.converged)):
-            report.add(method=rep.solver[i].name,
-                       converged=rep.converged[i],
-                       error=rep.norm_f[i],
-                       elapsed=rep.elapsed[i],
-                       iterations=rep.iterations[i])
-            results.convergence_reports.append(report)
+    # for rep in res.stats[0]:
+    #     report = ConvergenceReport()
+    #     for i in range(len(rep.converged)):
+    #         report.add(method=rep.solver[i].name,
+    #                    converged=rep.converged[i],
+    #                    error=rep.norm_f[i],
+    #                    elapsed=rep.elapsed[i],
+    #                    iterations=rep.iterations[i])
+    #         results.convergence_reports.append(report)
 
     return results

{gridcalengine-5.3.20 → gridcalengine-5.3.21}/GridCalEngine/Devices/Branches/overhead_line_type.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 from typing import List, Dict
+from warnings import warn
 import numpy as np
 from numpy import pi, log, sqrt
 from matplotlib import pyplot as plt
@@ -535,11 +536,17 @@ class OverheadLineType(EditableDevice):
         :param seq: Sequence number (0, 1, 2)
         :return: R1 [Ohm], X1[Ohm] and Bsh1 [S]
         """
-        a1 = 3 * circuit_idx + seq
-        R1 = self.z_seq[a1, a1].real
-        X1 = self.z_seq[a1, a1].imag
-        Bsh1 = self.y_seq[a1, a1].imag * 1e6
-        return R1, X1, Bsh1
+        self.compute()
+        if self.z_seq is not None and self.y_seq is not None:
+            a1 = 3 * circuit_idx + seq
+            R1 = self.z_seq[a1, a1].real
+            X1 = self.z_seq[a1, a1].imag
+            Bsh1 = self.y_seq[a1, a1].imag * 1e6
+            I_kA = self.Imax[circuit_idx]
+            return R1, X1, Bsh1, I_kA
+        else:
+            warn(f"{self.name} tower is incorrect :(")
+            return 0.0, 1e-20, 0.0
 
     def get_values(self, Sbase, length, circuit_index: int = 1, round_vals: bool = False, Vnom: float | None = None):
         """

{gridcalengine-5.3.20 → gridcalengine-5.3.21}/GridCalEngine/Devices/Diagrams/base_diagram.py

@@ -400,7 +400,7 @@ class BaseDiagram:
 
         node_devices = list()  # buses + fluid nodes
 
-        # Add buses, cn, busbars ---------------------------------------------------------------------------------------
+        # Add buses, cn, bus-bars --------------------------------------------------------------------------------------
         node_count = 0
         graph_node_dictionary = dict()
 

{gridcalengine-5.3.20 → gridcalengine-5.3.21}/GridCalEngine/Simulations/Clustering/clustering_driver.py

@@ -20,7 +20,7 @@ class ClusteringDriver(DriverTemplate):
     def __init__(self, grid: MultiCircuit, options: ClusteringAnalysisOptions):
         """
         Clustering analysis driver constructor
-        :param grid: Multicircuit instance
+        :param grid: MultiCircuit instance
         :param options: ClusteringAnalysisOptions
         """
         DriverTemplate.__init__(self, grid=grid)

{gridcalengine-5.3.20 → gridcalengine-5.3.21}/GridCalEngine/Simulations/PowerFlow/power_flow_driver.py

@@ -174,21 +174,7 @@ class PowerFlowDriver(DriverTemplate):
 
             res = gslv_pf(circuit=self.grid, pf_opt=self.options, time_series=False)
 
-            self.results = PowerFlowResults(n=self.grid.get_bus_number(),
-                                            m=self.grid.get_branch_number_wo_hvdc(),
-                                            n_hvdc=self.grid.get_hvdc_number(),
-                                            n_vsc=self.grid.get_vsc_number(),
-                                            n_gen=self.grid.get_generators_number(),
-                                            n_batt=self.grid.get_batteries_number(),
-                                            n_sh=self.grid.get_shunt_like_device_number(),
-                                            bus_names=res.bus_names,
-                                            branch_names=res.branch_names,
-                                            hvdc_names=res.hvdc_names,
-                                            vsc_names=self.grid.get_vsc_names(),
-                                            gen_names=self.grid.get_generator_names(),
-                                            batt_names=self.grid.get_battery_names(),
-                                            sh_names=self.grid.get_shunt_like_devices_names(),
-                                            bus_types=res.bus_types)
+
 
             self.results = translate_gslv_pf_results(self.grid, res)
             self.results.area_names = [a.name for a in self.grid.areas]

{gridcalengine-5.3.20 → gridcalengine-5.3.21}/GridCalEngine/__init__.py

@@ -365,3 +365,18 @@ if PROPERLY_LOADED_API:
             driver_contingencies.results.expand_clustered_results()
 
         return driver_contingencies.results
+
+
+    def clustering(circuit: MultiCircuit, n_points=100) -> ClusteringResults:
+        """
+        Perform a clustering analysis for time series
+        This will analyze the loads and non dispatchable generation to get the time
+        indices that best represent the whole time series. It included each sample probability
+        :param circuit: MultiCircuit
+        :param n_points: number of clustering points
+        :return: ClusteringResults
+        """
+        opts = ClusteringAnalysisOptions(n_points)
+        drv = ClusteringDriver(grid=circuit, options=opts)
+        drv.run()
+        return drv.results

{gridcalengine-5.3.20 → gridcalengine-5.3.21}/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.20"
+__GridCalEngine_VERSION__ = "5.3.21"
 
 url = 'https://github.com/SanPen/GridCal'
 

{gridcalengine-5.3.20 → gridcalengine-5.3.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GridCalEngine
-Version: 5.3.20
+Version: 5.3.21
 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.