GridCalEngine 5.1.27__tar.gz → 5.1.28__tar.gz

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

@@ -41,7 +41,7 @@ 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
@@ -132,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):

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

@@ -59,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.27 → 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.27 → 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.27 → 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.27 → 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.27 → 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.27 → 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.27"
+__GridCalEngine_VERSION__ = "5.1.28"
 
 url = 'https://github.com/SanPen/GridCal'
 

{GridCalEngine-5.1.27 → 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.27 → GridCalEngine-5.1.28}/PKG-INFO

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