VeraGridEngine 5.5.4__tar.gz → 5.5.5__tar.gz

{veragridengine-5.5.4 → veragridengine-5.5.5}/PKG-INFO

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

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Compilers/circuit_to_gslv.py

@@ -2433,17 +2433,66 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults", lo
     return results
 
 
-def gslv_contingencies(circuit: MultiCircuit,
-                       con_opt: ContingencyAnalysisOptions,
-                       time_series: bool = False,
-                       time_indices: Union[IntVec, None] = None) -> "pg.ContingencyAnalysisResults":
+def gslv_contingencies_snapshot(circuit: MultiCircuit,
+                                con_opt: ContingencyAnalysisOptions) -> "pg.ContingencyResultsSnapshot":
     """
     GSLV power flow
     :param circuit: MultiCircuit instance
-    :param pf_opt: Power Flow Options
+    :param con_opt: ContingencyAnalysisOptions
+    :return: GSLV Power flow results object
+    """
+    override_branch_controls = not (con_opt.pf_options.control_taps_modules and con_opt.pf_options.control_taps_phase)
+
+    gslv_grid, _ = to_gslv(circuit,
+                           use_time_series=False,
+                           time_indices=None,
+                           override_branch_controls=override_branch_controls,
+                           opf_results=None)
+
+    con_opt_gslv = pg.ContingencyAnalysisOptions(
+        use_provided_flows=con_opt.use_provided_flows,
+        Pf=con_opt.Pf,
+        pf_options=get_gslv_pf_options(con_opt.pf_options),
+        lin_options=pg.LinearAnalysisOptions(
+            distributeSlack=con_opt.lin_options.distribute_slack,
+            correctValues=con_opt.lin_options.correct_values,
+            ptdfThreshold=con_opt.lin_options.ptdf_threshold,
+            lodfThreshold=con_opt.lin_options.lodf_threshold,
+        ),
+        use_srap=con_opt.use_srap,
+        srap_max_power=con_opt.srap_max_power,
+        srap_top_n=con_opt.srap_top_n,
+        srap_dead_band=con_opt.srap_deadband,
+        srap_rever_to_nominal_rating=con_opt.srap_rever_to_nominal_rating,
+        detailed_massive_report=con_opt.detailed_massive_report,
+        contingency_dead_band=con_opt.contingency_deadband,
+        contingency_method=contingency_method_dict[con_opt.contingency_method],
+    )
+
+    n_threads = 0  # max threads
+
+    logger = pg.Logger()
+
+    res = pg.run_contingencies_at(grid=gslv_grid,
+                                  options=con_opt_gslv,
+                                  n_threads=n_threads,
+                                  t_idx=0,
+                                  # logger=logger
+                                  )
+
+    return res
+
+
+def gslv_contingencies_ts(circuit: MultiCircuit,
+                          con_opt: ContingencyAnalysisOptions,
+                          time_series: bool = False,
+                          time_indices: Union[IntVec, None] = None) -> "pg.ContingencyAnalysisResults":
+    """
+    GSLV power flow
+    :param circuit: MultiCircuit instance
+    :param con_opt: ContingencyAnalysisOptions
     :param time_series: Compile with VeraGrid time series?
     :param time_indices: Array of time indices
-    :param opf_results: Instance of
     :return: GSLV Power flow results object
     """
     override_branch_controls = not (con_opt.pf_options.control_taps_modules and con_opt.pf_options.control_taps_phase)

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Devices/Parents/load_parent.py

@@ -2,6 +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 __future__ import annotations
 
 from typing import Union
 import numpy as np

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Devices/multi_circuit.py

@@ -9,11 +9,11 @@ import cmath
 import copy
 import numpy as np
 import pandas as pd
-from typing import List, Dict, Tuple, Union, Set, Callable, Sequence, Any, TYPE_CHECKING
+from typing import List, Dict, Tuple, Union, Set, Sequence, TYPE_CHECKING
 from uuid import getnode as get_mac, uuid4
 import networkx as nx
 from matplotlib import pyplot as plt
-from scipy.sparse import csc_matrix, lil_matrix, coo_matrix
+from scipy.sparse import csc_matrix, lil_matrix
 
 from VeraGridEngine.Devices.assets import Assets
 from VeraGridEngine.Devices.Parents.editable_device import EditableDevice
@@ -24,7 +24,7 @@ import VeraGridEngine.Devices as dev
 from VeraGridEngine.Devices.types import ALL_DEV_TYPES, INJECTION_DEVICE_TYPES, FLUID_TYPES, AREA_TYPES, BRANCH_TYPES
 from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Topology.topology import find_different_states
-from VeraGridEngine.enumerations import DeviceType, ActionType, SubObjectType, ConverterControlType
+from VeraGridEngine.enumerations import DeviceType, ActionType, SubObjectType, ConverterControlType, ExternalGridMode
 
 
 if TYPE_CHECKING:
@@ -1729,6 +1729,52 @@ class MultiCircuit(Assets):
 
         return val
 
+    def get_Pgen(self) -> Vec:
+        """
+        Get the complex bus power Injections
+        :return: (nbus) [MW + j MVAr]
+        """
+        val = np.zeros(self.get_bus_number(), dtype=float)
+        bus_dict = self.get_bus_index_dict()
+
+        for elm in self.generators:
+            if elm.bus is not None:
+                k = bus_dict[elm.bus]
+                val[k] += elm.P
+
+        for elm in self.batteries:
+            if elm.bus is not None:
+                k = bus_dict[elm.bus]
+                val[k] += elm.P
+
+        for elm in self.static_generators:
+            if elm.bus is not None:
+                k = bus_dict[elm.bus]
+                val[k] += elm.P
+
+        for elm in self.external_grids:
+            if elm.mode != ExternalGridMode.VD:
+                if elm.bus is not None:
+                    k = bus_dict[elm.bus]
+                    val[k] += elm.P
+
+        return val
+
+    def get_Pload(self) -> Vec:
+        """
+        Get the complex bus power Injections
+        :return: (nbus) [MW + j MVAr]
+        """
+        val = np.zeros(self.get_bus_number(), dtype=float)
+        bus_dict = self.get_bus_index_dict()
+
+        for elm in self.loads:
+            if elm.bus is not None:
+                k = bus_dict[elm.bus]
+                val[k] += elm.P
+
+        return val
+
     def get_Sbus_prof_fixed(self) -> CxMat:
         """
         Get the complex bus power Injections considering those devices that cannot be dispatched

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Simulations/ContingencyAnalysis/Methods/linear_contingency_analysis.py

@@ -88,45 +88,47 @@ def linear_contingency_analysis(nc: NumericalCircuit,
     # for each contingency group
     for ic, multi_contingency in enumerate(linear_multiple_contingencies.multi_contingencies):
 
-        if multi_contingency.has_injection_contingencies():
-            contingency_group = linear_multiple_contingencies.contingency_groups_used[ic]
-            contingencies = linear_multiple_contingencies.contingency_group_dict[contingency_group.idtag]
-            # injections = nc.set_linear_con_or_ra_status(event_list=contingencies)
-            injections = nc.set_con_or_ra_status(event_list=contingencies)
-        else:
-            injections = None
-
-        c_flow = multi_contingency.get_contingency_flows(base_branches_flow=flows_n, injections=injections)
-        c_loading = c_flow / (nc.passive_branch_data.rates + 1e-9)
-
-        results.Sf[ic, :] = c_flow  # already in MW
-        results.Sbus[ic, :] = Pbus
-        results.loading[ic, :] = c_loading
-        results.report.analyze(t=t,
-                               t_prob=t_prob,
-                               mon_idx=mon_idx,
-                               nc=nc,
-                               base_flow=flows_n,
-                               base_loading=loadings_n,
-                               contingency_flows=c_flow,
-                               contingency_loadings=c_loading,
-                               contingency_idx=ic,
-                               contingency_group=linear_multiple_contingencies.contingency_groups_used[ic],
-                               using_srap=options.use_srap,
-                               srap_ratings=nc.passive_branch_data.protection_rates,
-                               srap_max_power=options.srap_max_power,
-                               srap_deadband=options.srap_deadband,
-                               contingency_deadband=options.contingency_deadband,
-                               srap_rever_to_nominal_rating=options.srap_rever_to_nominal_rating,
-                               multi_contingency=multi_contingency,
-                               PTDF=linear_analysis.PTDF,
-                               available_power=nc.bus_data.srap_availbale_power,
-                               srap_used_power=results.srap_used_power,
-                               F=F,
-                               T=T,
-                               bus_area_indices=bus_area_indices,
-                               area_names=area_names,
-                               top_n=options.srap_top_n)
+        if multi_contingency.enabled:
+
+            if multi_contingency.has_injection_contingencies():
+                contingency_group = linear_multiple_contingencies.contingency_groups_used[ic]
+                contingencies = linear_multiple_contingencies.contingency_group_dict[contingency_group.idtag]
+                # injections = nc.set_linear_con_or_ra_status(event_list=contingencies)
+                injections = nc.set_con_or_ra_status(event_list=contingencies)
+            else:
+                injections = None
+
+            c_flow = multi_contingency.get_contingency_flows(base_branches_flow=flows_n, injections=injections)
+            c_loading = c_flow / (nc.passive_branch_data.rates + 1e-9)
+
+            results.Sf[ic, :] = c_flow  # already in MW
+            results.Sbus[ic, :] = Pbus
+            results.loading[ic, :] = c_loading
+            results.report.analyze(t=t,
+                                   t_prob=t_prob,
+                                   mon_idx=mon_idx,
+                                   nc=nc,
+                                   base_flow=flows_n,
+                                   base_loading=loadings_n,
+                                   contingency_flows=c_flow,
+                                   contingency_loadings=c_loading,
+                                   contingency_idx=ic,
+                                   contingency_group=linear_multiple_contingencies.contingency_groups_used[ic],
+                                   using_srap=options.use_srap,
+                                   srap_ratings=nc.passive_branch_data.protection_rates,
+                                   srap_max_power=options.srap_max_power,
+                                   srap_deadband=options.srap_deadband,
+                                   contingency_deadband=options.contingency_deadband,
+                                   srap_rever_to_nominal_rating=options.srap_rever_to_nominal_rating,
+                                   multi_contingency=multi_contingency,
+                                   PTDF=linear_analysis.PTDF,
+                                   available_power=nc.bus_data.srap_availbale_power,
+                                   srap_used_power=results.srap_used_power,
+                                   F=F,
+                                   T=T,
+                                   bus_area_indices=bus_area_indices,
+                                   area_names=area_names,
+                                   top_n=options.srap_top_n)
 
         # report progress
         if t is None:

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Simulations/ContingencyAnalysis/contingency_analysis_driver.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 import numpy as np
 from typing import Union, List
 
-from VeraGridEngine.Compilers.circuit_to_gslv import gslv_contingencies
+from VeraGridEngine.Compilers.circuit_to_gslv import gslv_contingencies_snapshot
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 from VeraGridEngine.enumerations import EngineType, ContingencyMethod, SimulationTypes
 from VeraGridEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
@@ -192,10 +192,7 @@ class ContingencyAnalysisDriver(DriverTemplate):
         elif self.engine == EngineType.GSLV:
 
             self.report_text("Running contingencies in gslv...")
-            con_res = gslv_contingencies(circuit=self.grid,
-                                         con_opt=self.options,
-                                         time_series=False,
-                                         time_indices=None)
+            con_res = gslv_contingencies_snapshot(circuit=self.grid, con_opt=self.options)
 
             self.results = ContingencyAnalysisResults(
                 ncon=self.grid.get_contingency_groups_number(),
@@ -207,9 +204,12 @@ class ContingencyAnalysisDriver(DriverTemplate):
                 con_names=np.array(self.grid.get_contingency_group_names())
             )
 
-            # results.S[t, :] = res_t.S.real.max(axis=0)
-            self.results.max_flows = con_res.max_values.Sf[0, :]
-            self.results.max_loading = con_res.max_values.loading[0, :]
+            self.results.Sf = con_res.Sf
+            self.results.loading = con_res.loading
+            self.results.Sbus = con_res.Sbus
+            self.results.voltage = con_res.voltage
+            # self.results.max_flows = con_res.Sf[0, :]
+            # self.results.max_loading = con_res.loading[0, :]
 
         return self.results
 

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Simulations/ContingencyAnalysis/contingency_analysis_results.py

@@ -18,8 +18,14 @@ class ContingencyAnalysisResults(ResultsTemplate):
     Contingency analysis results
     """
 
-    def __init__(self, ncon: int, nbus: int, nbr: int,
-                 bus_names: StrVec, branch_names: StrVec, bus_types: IntVec, con_names: StrVec):
+    def __init__(self,
+                 ncon: int,
+                 nbus: int,
+                 nbr: int,
+                 bus_names: StrVec,
+                 branch_names: StrVec,
+                 bus_types: IntVec,
+                 con_names: StrVec):
         """
         ContingencyAnalysisResults
         :param ncon: number of contingencies

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Simulations/ContingencyAnalysis/contingency_analysis_ts_driver.py

@@ -26,7 +26,7 @@ from VeraGridEngine.Simulations.driver_template import TimeSeriesDriverTemplate
 from VeraGridEngine.Simulations.Clustering.clustering_results import ClusteringResults
 from VeraGridEngine.Compilers.circuit_to_newton_pa import newton_pa_contingencies, translate_contingency_report, \
     NEWTON_PA_AVAILABLE
-from VeraGridEngine.Compilers.circuit_to_gslv import (gslv_contingencies, GSLV_AVAILABLE)
+from VeraGridEngine.Compilers.circuit_to_gslv import (gslv_contingencies_ts, GSLV_AVAILABLE)
 from VeraGridEngine.Utils.NumericalMethods.weldorf_online_stddev import WeldorfOnlineStdDevMat
 
 
@@ -465,10 +465,10 @@ class ContingencyAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
         Run with Newton Power Analytics
         :return:
         """
-        res = gslv_contingencies(circuit=self.grid,
-                                 con_opt=self.options,
-                                 time_series=True,
-                                 time_indices=self.time_indices)
+        res = gslv_contingencies_ts(circuit=self.grid,
+                                    con_opt=self.options,
+                                    time_series=True,
+                                    time_indices=self.time_indices)
 
         time_array = self.grid.time_profile[self.time_indices]
 

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Simulations/LinearFactors/linear_analysis.py

@@ -535,6 +535,34 @@ class LinearAnalysis:
         else:
             raise Exception(f'Sbus has unsupported dimensions: {Sbus.shape}')
 
+    def get_injections(self, flows: Vec) -> Vec:
+        """
+        Get injections that satisfy the flows
+        :param flows: Array of flows (nbranch)
+        :return: Array of injections (nbus)
+        """
+        if flows.ndim == 1:
+
+            Pbus, _, _, _ = np.linalg.lstsq(self.PTDF, flows)
+
+            return Pbus
+        else:
+            raise Exception(f'flows has unsupported dimensions: {flows.shape}')
+
+    def get_injections_2d(self, flows: Mat) -> Mat:
+        """
+        Get injections that satisfy the flows
+        :param flows: Matrix of flows (time, nbranch)
+        :return: Matrix of injections (time, nbus)
+        """
+        if flows.ndim == 2:
+
+            Pbus, _, _, _ = np.linalg.lstsq(self.PTDF, flows)
+
+            return Pbus
+        else:
+            raise Exception(f'flows has unsupported dimensions: {flows.shape}')
+
 
 class LinearMultiContingency:
     """
@@ -587,6 +615,12 @@ class LinearMultiContingency:
         self.hvdc_odf = hvdc_odf
         self.vsc_odf = vsc_odf
 
+        # store flag for contingency emptyness
+        # self.enabled: bool = (self.mlodf_factors.nnz > 0
+        #                       or self.compensated_ptdf_factors.nnz > 0
+        #                       or injections_factor.sum() > 1)
+        self.enabled: bool = True
+
     def has_injection_contingencies(self) -> bool:
         """
         Check if this multi-contingency has bus injection modifications
@@ -1035,7 +1069,7 @@ class LinearAnalysisTs:
 
         return lin.get_flows(Sbus=P)
 
-    def get_time_flow(self, branch_idx: int, bus_idx: int, P: CxVec | Vec) -> CxVec | Vec:
+    def get_branch_flow_ts(self, branch_idx: int, bus_idx: int, P: CxVec | Vec) -> CxVec | Vec:
         """
         Get the flow time series of a single branch given the injection time series of a single bus
         :param branch_idx: Branch index
@@ -1056,7 +1090,7 @@ class LinearAnalysisTs:
 
         return flow_ts
 
-    def get_time_flows(self, P: CxVec | Vec) -> CxVec | Vec:
+    def get_flows_ts(self, P: CxMat | Mat) -> CxMat | Mat:
         """
         Get the flow time series of all branches given the injection time series all buses
         :param P: Bus injection time series
@@ -1075,3 +1109,25 @@ class LinearAnalysisTs:
             flow_ts[list_of_represented_time_steps, :] = lin.get_flows2d(Sbus=P[list_of_represented_time_steps, :])
 
         return flow_ts
+
+    def get_injections_ts(self, flows_ts: CxMat | Mat) -> CxMat | Mat:
+        """
+        Get the flow time series of all branches given the injection time series all buses
+        :param flows_ts: Branches flow time series
+        :return: Bus injection time series
+        """
+        # must have the same size
+        assert flows_ts.shape[0] == self.nt
+        assert flows_ts.shape[1] == self.nbr
+
+        Pbus = np.zeros((self.nt, self.nbus))
+
+        for t_idx, list_of_represented_time_steps in self.groups.items():
+            # get the linear analysis
+            lin: LinearAnalysis = self._linear_analysis[t_idx]
+
+            Pbus[list_of_represented_time_steps, :] = lin.get_injections_2d(
+                flows=flows_ts[list_of_represented_time_steps, :]
+            )
+
+        return Pbus

{veragridengine-5.5.4 → veragridengine-5.5.5}/VeraGridEngine/Topology/GridReduction/di_shi_grid_reduction.py

@@ -416,26 +416,27 @@ def di_shi_reduction(grid: MultiCircuit,
 
     # add loads
     for i, S in enumerate(dSred):
-        ld = dev.Load(name=f"compensation {i}", P=S.real, Q=S.imag)
-        grid.add_load(bus=grid.buses[i], api_obj=ld)
+        if abs(S) > tol:
+            ld = dev.Load(name=f"compensation {i}", P=S.real, Q=S.imag)
+            grid.add_load(bus=grid.buses[i], api_obj=ld)
 
     return grid, logger
 
 
-if __name__ == '__main__':
-    import VeraGridEngine as gce
-
-    fname = '/home/santi/Documentos/Git/GitHub/VeraGrid/src/tests/data/grids/Matpower/case9.m'
-    fname_expected = '/home/santi/Documentos/Git/GitHub/VeraGrid/src/tests/data/grids/Matpower/ieee9_reduced.m'
-
-    reduction_bus_indices_ = np.array([2, 4, 5, 6])
-
-    grid_ = gce.open_file(fname)
-    grid_expected = gce.open_file(fname_expected)
-
-    grid_red, logger_ = di_shi_reduction(grid=grid_.copy(),
-                                         reduction_bus_indices=reduction_bus_indices_,
-                                         V0=gce.power_flow(grid_).voltage,
-                                         tol=1e-8)
-
-    logger_.print()
+# if __name__ == '__main__':
+#     import VeraGridEngine as gce
+#
+#     fname = '/home/santi/Documentos/Git/GitHub/VeraGrid/src/tests/data/grids/Matpower/case9.m'
+#     fname_expected = '/home/santi/Documentos/Git/GitHub/VeraGrid/src/tests/data/grids/Matpower/ieee9_reduced.m'
+#
+#     reduction_bus_indices_ = np.array([2, 4, 5, 6])
+#
+#     grid_ = gce.open_file(fname)
+#     grid_expected = gce.open_file(fname_expected)
+#
+#     grid_red, logger_ = di_shi_reduction(grid=grid_.copy(),
+#                                          reduction_bus_indices=reduction_bus_indices_,
+#                                          V0=gce.power_flow(grid_).voltage,
+#                                          tol=1e-8)
+#
+#     logger_.print()