GridCalEngine 5.1.26__tar.gz → 5.1.28__tar.gz

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/Devices/Branches/overhead_line_type.py

@@ -14,6 +14,9 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+from __future__ import annotations
+
+from typing import List
 import numpy as np
 from numpy import pi, log, sqrt
 from matplotlib import pyplot as plt
@@ -34,8 +37,11 @@ Typical values of earth
 
 
 class WireInTower:
+    """
+    Wire -> Tower association
+    """
 
-    def __init__(self, wire: Wire, xpos=0, ypos=0, phase=1):
+    def __init__(self, wire: Wire, xpos: float = 0.0, ypos: float = 0.0, phase: int = 1):
         """
         Wire in a tower
         :param wire: Wire instance
@@ -43,22 +49,22 @@ class WireInTower:
         :param ypos: y position in m
         :param phase: 0->Neutral, 1->A, 2->B, 3->C
         """
-        self.wire = wire
+        self.wire: Wire = wire
 
-        self.name = wire.name
+        self.name: str = wire.name
 
-        self.xpos = xpos
+        self.xpos: float = xpos
 
-        self.ypos = ypos
+        self.ypos: float = ypos
 
-        self.phase = phase
+        self.phase: int = phase
 
         self.device_type = DeviceType.WireDevice
 
 
 class OverheadLineType(EditableDevice):
 
-    def __init__(self, name='Tower', idtag=None):
+    def __init__(self, name='Tower', idtag: str | None = None):
         """
         Overhead line editor
         :param name: name
@@ -70,7 +76,7 @@ class OverheadLineType(EditableDevice):
                                 device_type=DeviceType.OverheadLineTypeDevice)
 
         # list of wires in the tower
-        self.wires_in_tower = list()
+        self.wires_in_tower: List[WireInTower] = list()
 
         self.Vnom = 1.0
 
@@ -126,12 +132,15 @@ 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')
 
-    def add_wire(self, w: WireInTower):
+    def add_wire_relationship(self, wire: Wire, xpos: float = 0.0, ypos: float = 0.0, phase: int = 1):
         """
-
-        :param w:
-        :return:
+        Wire in a tower
+        :param wire: Wire instance
+        :param xpos: x position in m
+        :param ypos: y position in m
+        :param phase: 0->Neutral, 1->A, 2->B, 3->C
         """
+        w = WireInTower(wire=wire, xpos=xpos, ypos=ypos, phase=phase)
         self.wires_in_tower.append(w)
 
     def z_series(self):
@@ -184,9 +193,9 @@ class OverheadLineType(EditableDevice):
         if n > 0:
             x = np.zeros(n)
             y = np.zeros(n)
-            for i, wire in enumerate(self.wires_in_tower):
-                x[i] = wire.xpos
-                y[i] = wire.ypos
+            for i, wire_tower in enumerate(self.wires_in_tower):
+                x[i] = wire_tower.xpos
+                y[i] = wire_tower.ypos
 
             ax.plot(x, y, '.')
             ax.set_title('Tower wire position')
@@ -216,7 +225,7 @@ class OverheadLineType(EditableDevice):
             if wire_i.ypos != 0.0:
                 all_y_zero = False
 
-            if wire_i.wire.gmr < 0:
+            if wire_i.wire.GMR < 0:
                 logger.add('The wires' + wire_i.name + '(' + str(i) + ') has GRM=0 which is impossible.')
                 return False
 
@@ -262,18 +271,18 @@ class OverheadLineType(EditableDevice):
 
         if all_ok:
             # Impedances
-            self.z_abcn, \
-                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_abcn,
+             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)
 
             # 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_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)
 
             # compute the tower rating in kA
             self.Imax = self.compute_rating()
@@ -330,7 +339,7 @@ class OverheadLineType(EditableDevice):
 
         return R1, X1, B1, R0, X0, B0, rate
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
@@ -510,7 +519,12 @@ def calc_z_matrix(wires: list, f=50, rho=100):
     for i, wire_i in enumerate(wires):
 
         # self impedance
-        z_prim[i, i] = z_ii(r_i=wire_i.wire.r, x_i=wire_i.wire.x, h_i=wire_i.ypos, gmr_i=wire_i.wire.gmr, f=f, rho=rho)
+        z_prim[i, i] = z_ii(r_i=wire_i.wire.R,
+                            x_i=wire_i.wire.X,
+                            h_i=wire_i.ypos,
+                            gmr_i=wire_i.wire.GMR,
+                            f=f,
+                            rho=rho)
 
         # mutual impedances
         for j, wire_j in enumerate(wires):
@@ -583,7 +597,7 @@ def calc_y_matrix(wires: list, f=50, rho=100):
 
         # self impedance
         if wire_i.ypos > 0:
-            p_prim[i, i] = one_two_pi_e0 * log(2 * wire_i.ypos / (wire_i.wire.gmr + 1e-12))
+            p_prim[i, i] = one_two_pi_e0 * log(2 * wire_i.ypos / (wire_i.wire.GMR + 1e-12))
         else:
             p_prim[i, i] = 0
             print(wire_i.name, 'has y=0 !')

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/Devices/Branches/wire.py

@@ -29,7 +29,8 @@ class Wire(EditableDevice):
                  max_current: float = 1.0,
                  stranding: str = "",
                  material: str = "",
-                 diameter: float = 0.0):
+                 diameter: float = 0.0,
+                 code: str = ""):
         """
         Wire definition
         :param name: Name of the wire type
@@ -37,13 +38,16 @@ class Wire(EditableDevice):
         :param r: Resistance per unit length (Ohm / km)
         :param x: Reactance per unit length (Ohm / km)
         :param max_current: Maximum current of the conductor in (kA)
-
+        :param stranding: Stranding of the wire type
+        :param material: Material of the wire type
+        :param diameter: Diameter of the wire type
+        :param code: Code of the wire type
         """
 
         EditableDevice.__init__(self,
                                 name=name,
                                 idtag=idtag,
-                                code='',
+                                code=code,
                                 device_type=DeviceType.WireDevice)
 
         # self.wire_name = name
@@ -55,9 +59,9 @@ class Wire(EditableDevice):
         self.GMR = gmr
         self.max_current = max_current
 
-        self.register(key='R', units='Ohm/km', tpe=float, definition='resistance of the conductor')
-        self.register(key='X', units='Ohm/km', tpe=float, definition='reactance of the conductor')
-        self.register(key='GMR', units='m', tpe=float, definition='Geometric Mean Radius of the conductor')
+        self.register(key='R', units='Ohm/km', tpe=float, definition='resistance of the conductor', old_names=['r'])
+        self.register(key='X', units='Ohm/km', tpe=float, definition='reactance of the conductor', old_names=['x'])
+        self.register(key='GMR', units='m', tpe=float, definition='Geometric Mean Radius of the conductor', old_names=['gmr'])
         self.register(key='max_current', units='kA', tpe=float, definition='Maximum current of the conductor')
         self.register(key='stranding', tpe=str, definition='Stranding of wire')
         self.register(key='material', tpe=str, definition='Material of wire')

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/Devices/profile.py

@@ -483,3 +483,13 @@ class Profile:
         :param data: array of data values
         """
         self._sparse_array.set_sparse_data_from_data(indptr=indptr, data=data)
+
+    def fix_nan(self, default_value: float = 0.0):
+        """
+        Replace NaN values with default value in-place
+        :param default_value: some value to replace the NaN with
+        """
+        if self.dtype == float:
+            if not self._is_sparse:
+                if self._dense_array is not None:
+                    np.nan_to_num(self._dense_array, nan=default_value)  # this is supposed to happen in-place

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/IO/__init__.py

@@ -1,11 +1,18 @@
 
 
 from GridCalEngine.IO.cim import cgmesProfile, CIMImport, CIMExport
+
 from GridCalEngine.IO.dgs.dgs_parser import dgs_to_circuit
+
 from GridCalEngine.IO.others.dpx_parser import load_dpx
 from GridCalEngine.IO.others.ipa_parser import load_iPA
+
 from GridCalEngine.IO.gridcal.json_parser import save_json_file_v3, parse_json_data_v3
+from GridCalEngine.IO.gridcal.excel_interface import interpret_excel_v3, interprete_excel_v2
+from GridCalEngine.IO.gridcal.results_export import export_drivers, export_results
+
 from GridCalEngine.IO.matpower.matpower_parser import parse_matpower_file, get_matpower_case_data
+
 from GridCalEngine.IO.raw.raw_parser_legacy import PSSeParser
-from GridCalEngine.IO.gridcal.excel_interface import interpret_excel_v3, interprete_excel_v2
+
 from GridCalEngine.IO.file_handler import FileOpen, FileSave, FileSavingOptions

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/IO/gridcal/excel_interface.py

@@ -547,23 +547,35 @@ def interprete_excel_v2(circuit: MultiCircuit, data):
 
     # Add the overhead_line_types ##################################################################################
     if 'overhead_line_types' in data.keys():
-        lst = data['overhead_line_types']
+        df = data['overhead_line_types']
         if data['overhead_line_types'].values.shape[0] > 0:
-            for tower_name in lst['tower_name'].unique():
-                tower = dev.OverheadLineType()
-                vals = lst[lst['tower_name'] == tower_name].values
+            for tower_name in df['tower_name'].unique():
+                obj = dev.OverheadLineType()
+                dft = df[df['tower_name'] == tower_name]
+                vals = dft.values
+
+                wire_prop = df.columns.values[len(obj.registered_properties):]
 
                 # set the tower values
-                set_object_attributes(tower, tower.registered_properties.keys(), vals[0, :])
+                set_object_attributes(obj, obj.registered_properties.keys(), vals[0, :])
 
                 # add the wires
-                for i in range(vals.shape[0]):
-                    wire = dev.Wire()
-                    set_object_attributes(wire, tower.get_wire_properties(), vals[i, len(tower.registered_properties):])
-                    tower.add_wire(wire)
+                if len(wire_prop) == 7:
+                    for i in range(vals.shape[0]):
+                        # ['wire_name' 'xpos' 'ypos' 'phase' 'r' 'x' 'gmr']
+                        name = dft['wire_name'].values[i]
+                        gmr = dft['gmr'].values[i]
+                        r = dft['r'].values[i]
+                        x = dft['x'].values[i]
+                        xpos = dft['xpos'].values[i]
+                        ypos = dft['ypos'].values[i]
+                        phase = dft['phase'].values[i]
+
+                        wire = dev.Wire(name=name, gmr=gmr, r=r, x=x)
+                        obj.add_wire_relationship(wire=wire, xpos=xpos, ypos=ypos, phase=phase)
 
-                circuit.add_overhead_line(tower)
-                branch_types[str(tower)] = tower
+                circuit.add_overhead_line(obj)
+                branch_types[str(obj)] = obj
         else:
             pass
     else:
@@ -1022,8 +1034,7 @@ def interpret_excel_v3(circuit: MultiCircuit, data):
                         phase = dft['phase'].values[i]
 
                         wire = dev.Wire(name=name, gmr=gmr, r=r, x=x)
-                        w = dev.WireInTower(wire=wire, xpos=xpos, ypos=ypos, phase=phase)
-                        obj.add_wire(w)
+                        obj.add_wire_relationship(wire=wire, xpos=xpos, ypos=ypos, phase=phase)
 
                 circuit.add_overhead_line(obj)
                 branch_types[str(obj)] = obj

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/IO/gridcal/pack_unpack.py

@@ -1436,9 +1436,7 @@ def parse_gridcal_data(data: Dict[str, Union[str, float, pd.DataFrame, Dict[str,
                 xpos = df['xpos'].values[i]
                 ypos = df['ypos'].values[i]
                 phase = df['phase'].values[i]
-
-                w = dev.WireInTower(wire=wire, xpos=xpos, ypos=ypos, phase=phase)
-                tower.add_wire(w)
+                tower.add_wire_relationship(wire=wire, xpos=xpos, ypos=ypos, phase=phase)
 
     # create diagrams --------------------------------------------------------------------------------------------------
     if text_func is not None:

GridCalEngine-5.1.28/GridCalEngine/IO/gridcal/results_export.py

@@ -0,0 +1,121 @@
+# GridCal
+# Copyright (C) 2015 - 2024 Santiago Peñate Vera
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+from __future__ import annotations
+
+import os
+from typing import List, Callable, Union, TYPE_CHECKING
+from io import StringIO
+import zipfile
+from GridCalEngine.basic_structures import Logger
+
+if TYPE_CHECKING:
+    from GridCalEngine.Simulations.types import DRIVER_OBJECTS, RESULTS_OBJECTS
+
+
+def export_results(results_list: List[RESULTS_OBJECTS],
+                   file_name: str,
+                   text_func: Union[Callable[[str], None], None] = None,
+                   progress_func: Union[Callable[[float], None], None] = None,
+                   logger: Logger = Logger()):
+    """
+    Constructor
+    :param results_list: list of GridCal simulation results
+    :param file_name: name of the file where to save (.zip)
+    :param text_func: text function
+    :param progress_func: progress function
+    :param logger: logging object
+    """
+
+    # try:
+    path, fname = os.path.split(file_name)
+
+    if text_func is not None:
+        text_func('Flushing ' + fname + ' into ' + fname + '...')
+
+    # open zip file for writing
+    try:
+        with zipfile.ZipFile(file_name, 'w', zipfile.ZIP_DEFLATED) as myzip:
+
+            n = len(results_list)
+
+            for k, results in enumerate(results_list):
+
+                # deactivate plotting
+                results.deactivate_plotting()
+
+                if progress_func is not None:
+                    progress_func((k + 1) / n * 100.0)
+
+                if isinstance(results.available_results, dict):
+                    available_res = [e for tpe, lst in results.available_results.items() for e in lst]
+                else:
+                    available_res = results.available_results
+
+                for available_result in available_res:
+
+                    # ge the result type definition
+                    result_name = str(available_result.value)
+
+                    if text_func is not None:
+                        text_func('flushing ' + results.name + ' ' + result_name)
+
+                    # save the DataFrame to the buffer
+                    mdl = results.mdl(result_type=available_result)
+
+                    if mdl is not None:
+                        with StringIO() as buffer:
+                            filename = results.name + ' ' + result_name + '.csv'
+                            try:
+                                mdl.save_to_csv(buffer)
+                                myzip.writestr(filename, buffer.getvalue())
+                            except ValueError:
+                                logger.add_error('Value error', filename)
+                    else:
+                        logger.add_info('No results for ' + results.name + ' - ' + result_name)
+
+                # reactivate plotting
+                results.activate_plotting()
+
+    except PermissionError:
+        logger.add('Permission error.\nDo you have the file open?')
+
+    # post events
+    if text_func is not None:
+        text_func('Done!')
+
+
+def export_drivers(drivers_list: List[DRIVER_OBJECTS],
+                   file_name: str,
+                   text_func: Union[Callable[[str], None], None] = None,
+                   progress_func: Union[Callable[[float], None], None] = None,
+                   logger: Logger = Logger()):
+    """
+    Constructor
+    :param drivers_list: list of GridCal simulation drivers
+    :param file_name: name of the file where to save (.zip)
+    :param text_func: text function
+    :param progress_func: progress function
+    :param logger: logging object
+    """
+
+    results_list = [drv.results for drv in drivers_list]
+
+    export_results(results_list=results_list,
+                   file_name=file_name,
+                   text_func=text_func,
+                   progress_func=progress_func,
+                   logger=logger)

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/Simulations/ContingencyAnalysis/contingency_analysis_ts_driver.py

@@ -21,7 +21,6 @@ from typing import Union
 from GridCalEngine.basic_structures import IntVec, StrVec
 from GridCalEngine.enumerations import EngineType, ContingencyMethod
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
-from GridCalEngine.Simulations.LinearFactors.linear_analysis import LinearMultiContingencies
 from GridCalEngine.Simulations.LinearFactors.linear_analysis_options import LinearAnalysisOptions
 from GridCalEngine.Simulations.LinearFactors.linear_analysis_ts_driver import LinearAnalysisTimeSeriesDriver
 from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_driver import (ContingencyAnalysisOptions,
@@ -107,8 +106,6 @@ class ContingencyAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
             clustering_results=self.clustering_results
         )
 
-        # linear_multiple_contingencies = LinearMultiContingencies(grid=self.grid)
-
         cdriver = ContingencyAnalysisDriver(grid=self.grid,
                                             options=self.options,
                                             linear_multiple_contingencies=None  # it is computed inside

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/Simulations/PowerFlow/power_flow_results.py

@@ -393,14 +393,15 @@ class PowerFlowResults(ResultsTemplate):
             va_rad = np.angle(self.voltage, deg=False)
             data = np.c_[vm, va]
 
-            plt.ion()
-            color_norm = plt_colors.LogNorm()
-            fig = plt.figure(figsize=(8, 6))
-            ax3 = plt.subplot(1, 1, 1, projection='polar')
-            sc3 = ax3.scatter(va_rad, vm, c=vm, norm=color_norm)
-            fig.suptitle(result_type.value)
-            plt.tight_layout()
-            plt.show()
+            if self.plotting_allowed():
+                plt.ion()
+                color_norm = plt_colors.LogNorm()
+                fig = plt.figure(figsize=(8, 6))
+                ax3 = plt.subplot(1, 1, 1, projection='polar')
+                sc3 = ax3.scatter(va_rad, vm, c=vm, norm=color_norm)
+                fig.suptitle(result_type.value)
+                plt.tight_layout()
+                plt.show()
 
             return ResultsTable(data=data,
                                 index=self.bus_names,

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/Simulations/results_template.py

@@ -78,7 +78,7 @@ class ResultsTemplate:
 
         self.data_variables: Dict[str, ResultsProperty] = dict()
 
-        self.time_array: Union[DateVec, None] = time_array
+        self._time_array: Union[DateVec, None] = time_array
 
         if clustering_results:
             self.clustering_results = clustering_results
@@ -101,6 +101,41 @@ class ResultsTemplate:
         self.bus_area_indices: IntVec = None
         self.area_names: StrVec = None
 
+        self.__show_plot = True
+
+    @property
+    def time_array(self) -> DateVec:
+        """
+        Array of time steps
+        :return:
+        """
+        return self._time_array
+
+    @time_array.setter
+    def time_array(self, time_array: DateVec):
+        self._time_array = time_array
+
+    def plotting_allowed(self) -> bool:
+        """
+
+        :return:
+        """
+        return self.__show_plot
+
+    def activate_plotting(self):
+        """
+
+        :return:
+        """
+        self.__show_plot = True
+
+    def deactivate_plotting(self):
+        """
+
+        :return:
+        """
+        self.__show_plot = False
+
     def register(self, name: str, tpe: Union[Vec, Mat, CxVec, CxMat], old_names: Union[None, List[str]] = None):
         """
         Register a results variable for disk persistence

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/__version__.py

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

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/GridCalEngine/api.py

@@ -155,3 +155,73 @@ def acopf(grid: MultiCircuit,
                                   pf_init=pf_init)
 
     return acopf_res
+
+
+def contingencies_ts(circuit: MultiCircuit,
+                     use_clustering: bool = False,
+                     n_points: int = 100,
+                     use_srap=False,
+                     srap_max_power=1300.0,
+                     srap_top_n=5,
+                     srap_deadband=10,
+                     srap_rever_to_nominal_rating=True,
+                     detailed_massive_report=True,
+                     contingency_deadband=0.0,
+                     contingency_method=ContingencyMethod.PTDF) -> ContingencyAnalysisTimeSeriesResults:
+    """
+    Run a time series contingency analysis
+    :param circuit: MultiCircuit instance
+    :param use_clustering: Use clustering?
+    :param n_points: Number of points for clustering
+    :param use_srap: Use SRAP?
+    :param srap_max_power: Max power in SRAP
+    :param srap_top_n: Top number of SRAP nodes to consider
+    :param srap_deadband: Deadband for SRAP power
+    :param srap_rever_to_nominal_rating: Revert to nominal rating for SRAP flow
+    :param detailed_massive_report: Detailed massive report?
+    :param contingency_deadband: Deadband for contingency analysis
+    :param contingency_method: Contingency analysis method (ContingencyMethod)
+    :return: ContingencyAnalysisTimeSeriesResults
+    """
+
+    if use_clustering:
+        options_clustering = ClusteringAnalysisOptions(n_points=n_points)
+        driver_clustering = ClusteringDriver(grid=circuit, options=options_clustering)
+        driver_clustering.run()
+        clustering_results_ = driver_clustering.results
+    else:
+        clustering_results_ = None
+
+    # declare the contingency analysis options
+    options_contingencies = ContingencyAnalysisOptions(
+        use_provided_flows=False,
+        Pf=None,
+        pf_options=PowerFlowOptions(SolverType.DC),
+        lin_options=LinearAnalysisOptions(),
+        use_srap=use_srap,
+        srap_max_power=srap_max_power,
+        srap_top_n=srap_top_n,
+        srap_deadband=srap_deadband,
+        srap_rever_to_nominal_rating=srap_rever_to_nominal_rating,
+        detailed_massive_report=detailed_massive_report,
+        contingency_deadband=contingency_deadband,
+        contingency_method=contingency_method,
+        contingency_groups=circuit.contingency_groups
+    )
+
+    # declare the contingency drivers
+    driver_contingencies = ContingencyAnalysisTimeSeriesDriver(
+        grid=circuit,
+        options=options_contingencies,
+        time_indices=circuit.get_all_time_indices(),
+        clustering_results=clustering_results_
+    )
+
+    # run!
+    driver_contingencies.run()
+
+    if use_clustering:
+        # this reconciles the results time steps properly
+        driver_contingencies.results.expand_clustered_results()
+
+    return driver_contingencies.results

{GridCalEngine-5.1.26 → GridCalEngine-5.1.28}/PKG-INFO

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