VeraGridEngine 5.5.5__tar.gz → 5.5.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.5.5
+Version: 5.5.7
 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.5 → veragridengine-5.5.7}/VeraGridEngine/DataStructures/numerical_circuit.py

@@ -244,7 +244,8 @@ class NumericalCircuit:
             'pqv',
             'p',
             'pv',
-            'vd'
+            'vd',
+            # 'pqpv',
         ],
         "Branch arrays": [
             'tap_f',
@@ -912,6 +913,8 @@ class NumericalCircuit:
         )
         return Qmax_bus, Qmin_bus
 
+
+
     def get_structure(self, structure_type: str) -> pd.DataFrame:
         """
         Get a DataFrame with the input.
@@ -927,6 +930,7 @@ class NumericalCircuit:
             PfAdvancedFormulation)
         from VeraGridEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions
 
+
         formulation = PfAdvancedFormulation(V0=self.bus_data.Vbus,
                                             S0=Sbus,
                                             I0=self.get_current_injections_pu(),
@@ -1078,12 +1082,13 @@ class NumericalCircuit:
 
         elif structure_type == "B'":
             adm = self.get_fast_decoupled_amittances()
-            if adm.B1.shape[0] == len(idx.pqpv):
+            print("B':",adm.B1.toarray())
+            if adm.B1.shape[0] == len(idx.pq):
                 data = adm.B1.toarray()
-                names = self.bus_data.names[idx.pqpv]
+                names = self.bus_data.names[idx.pq]
             else:
-                data = adm.B1[np.ix_(idx.pqpv, idx.pqpv)].toarray()
-                names = self.bus_data.names[idx.pqpv]
+                data = adm.B1[np.ix_(idx.pq, idx.pq)].toarray()
+                names = self.bus_data.names[idx.pq]
 
             df = pd.DataFrame(
                 data=data,
@@ -1093,6 +1098,7 @@ class NumericalCircuit:
 
         elif structure_type == "B''":
             adm = self.get_fast_decoupled_amittances()
+            print("B'':", adm.B2.toarray())
             if adm.B2.shape[0] == len(idx.pq):
                 data = adm.B2.toarray()
                 names = self.bus_data.names[idx.pq]
@@ -1206,12 +1212,12 @@ class NumericalCircuit:
                 index=self.bus_data.names[idx.vd],
             )
 
-        elif structure_type == 'pqpv':
-            df = pd.DataFrame(
-                data=idx.pqpv.astype(int).astype(str),
-                columns=['pqpv'],
-                index=self.bus_data.names[idx.pqpv],
-            )
+        # elif structure_type == 'pqpv':
+        #     df = pd.DataFrame(
+        #         data=idx.pqpv.astype(int).astype(str),
+        #         columns=['pqpv'],
+        #         index=self.bus_data.names[idx.pqpv],
+        #     )
 
         elif structure_type == 'tap_f':
             df = pd.DataFrame(

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

@@ -26,7 +26,6 @@ from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Topology.topology import find_different_states
 from VeraGridEngine.enumerations import DeviceType, ActionType, SubObjectType, ConverterControlType, ExternalGridMode
 
-
 if TYPE_CHECKING:
     from VeraGridEngine.Simulations.OPF.opf_ts_results import OptimalPowerFlowTimeSeriesResults
     from VeraGridEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
@@ -2843,8 +2842,13 @@ class MultiCircuit(Assets):
         for i, elm in enumerate(self.get_hvdc()):
             elm.Pset.set(results.hvdc_Pf[i])
 
-    def get_reduction_sets(self, reduction_bus_indices: Sequence[int],
-                           add_vsc=False, add_hvdc=False, add_switch=True) -> Tuple[IntVec, IntVec, IntVec, IntVec]:
+    def get_reduction_sets(
+            self,
+            reduction_bus_indices: Sequence[int],
+            add_vsc=False,
+            add_hvdc=False,
+            add_switch=True
+    ) -> Tuple[IntVec, IntVec, IntVec, IntVec, IntVec]:
         """
         Generate the set of bus indices for grid reduction
         :param reduction_bus_indices: array of bus indices to reduce (external set)
@@ -2858,6 +2862,7 @@ class MultiCircuit(Assets):
         boundary_set = set()
         internal_set = set()
         boundary_branches = list()
+        internal_branches = list()
 
         for k, branch in enumerate(self.get_branches(add_vsc=add_vsc, add_hvdc=add_hvdc, add_switch=add_switch)):
             f = bus_idx_dict[branch.bus_from]
@@ -2881,6 +2886,7 @@ class MultiCircuit(Assets):
                     # f nor t are in the external set: both belong to the internal set
                     internal_set.add(f)
                     internal_set.add(t)
+                    internal_branches.append(k)
 
         # buses cannot be in both the internal and boundary set
         elms_to_remove = list()
@@ -2896,8 +2902,9 @@ class MultiCircuit(Assets):
         boundary = np.sort(np.array(list(boundary_set)))
         internal = np.sort(np.array(list(internal_set)))
         boundary_branches = np.array(boundary_branches)
+        internal_branches = np.array(internal_branches)
 
-        return external, boundary, internal, boundary_branches
+        return external, boundary, internal, boundary_branches, internal_branches
 
     def get_buses_from_objects(self, elements: List[ALL_DEV_TYPES]) -> Set[dev.Bus]:
         """

{veragridengine-5.5.5 → veragridengine-5.5.7}/VeraGridEngine/Simulations/ContingencyAnalysis/Methods/nonlinear_contingency_analysis.py

@@ -72,7 +72,7 @@ def nonlinear_contingency_analysis(nc: NumericalCircuit,
     mon_idx = nc.passive_branch_data.get_monitor_enabled_indices()
 
     # run 0
-    pf_res_0 = multi_island_pf_nc(nc=nc,
+    base_res = multi_island_pf_nc(nc=nc,
                                   options=pf_opts)
 
     if options.use_srap:
@@ -112,7 +112,7 @@ def nonlinear_contingency_analysis(nc: NumericalCircuit,
         # run
         pf_res = multi_island_pf_nc(nc=nc,
                                     options=pf_opts,
-                                    V_guess=pf_res_0.voltage,
+                                    V_guess=base_res.voltage,
                                     logger=logger)
 
         results.Sf[ic, :] = pf_res.Sf
@@ -125,8 +125,8 @@ def nonlinear_contingency_analysis(nc: NumericalCircuit,
                                t_prob=t_prob,
                                mon_idx=mon_idx,
                                nc=nc,
-                               base_flow=np.abs(pf_res_0.Sf),
-                               base_loading=np.abs(pf_res_0.loading),
+                               base_flow=np.abs(base_res.Sf),
+                               base_loading=np.abs(base_res.loading),
                                contingency_flows=np.abs(pf_res.Sf),
                                contingency_loadings=np.abs(pf_res.loading),
                                contingency_idx=ic,

{veragridengine-5.5.5 → veragridengine-5.5.7}/VeraGridEngine/Simulations/Rms/initialization.py

@@ -47,13 +47,14 @@ def _compile_equation(eqs: Sequence[Expr],
 
 
 def compose_system_block(grid: MultiCircuit,
-                          power_flow_results: PowerFlowResults, vars2device:Dict[int, PhysicalDevice]) -> Tuple[Block, Dict[Tuple[int, str], float]]:
+                          power_flow_results: PowerFlowResults, vars2device:Dict[int, PhysicalDevice], vars_glob_name2uid: Dict[str, int]) -> Tuple[Block, Dict[Tuple[int, str], float]]:
 
     """
     Compose all RMS models
     :param grid:
     :param power_flow_results:
     :param vars2device: dictionary relating uid of vars with the device they belong to
+    :param vars_glob_name2uid: dictionary relating global name of the variable and uid (used when showing results)
     :return: System block and initial guess dictionary
     """
     # already computed grid power flow
@@ -66,6 +67,7 @@ def compose_system_block(grid: MultiCircuit,
     sys_block = Block(children=[], in_vars=[])
 
     sys_block.vars2device = vars2device
+    sys_block.vars_glob_name2uid = vars_glob_name2uid
 
     # initialize containers
     init_guess: Dict[Tuple[int, str], float] = {}
@@ -228,9 +230,10 @@ def initialize_rms(grid: MultiCircuit, power_flow_results, logger: Logger = Logg
     Initialize all RMS models
     """
 
-    # instantiate vars2device dict
+    # instantiate vars2device  and vars_glob_name2uid dicts
 
     vars2device:Dict[int, PhysicalDevice] = dict()
+    vars_glob_name2uid: Dict[str, int] = dict()
     # find events
     rms_events = grid.rms_events
 
@@ -253,8 +256,10 @@ def initialize_rms(grid: MultiCircuit, power_flow_results, logger: Logger = Logg
         bus_dict[elm] = i
         for state_var in elm.rms_model.model.state_vars:
             vars2device[state_var.uid] = elm
+            vars_glob_name2uid[state_var.name] = state_var.uid
         for algeb_var in elm.rms_model.model.algebraic_vars:
             vars2device[algeb_var.uid] = elm
+            vars_glob_name2uid[algeb_var.name] = algeb_var.uid
 
     # initialize branches
     for elm in grid.get_branches_iter(add_vsc=True, add_hvdc=True, add_switch=True):
@@ -270,8 +275,10 @@ def initialize_rms(grid: MultiCircuit, power_flow_results, logger: Logger = Logg
 
         for state_var in elm.rms_model.model.state_vars:
             vars2device[state_var.uid] = elm
+            vars_glob_name2uid[state_var.name] = state_var.uid
         for algeb_var in elm.rms_model.model.algebraic_vars:
             vars2device[algeb_var.uid] = elm
+            vars_glob_name2uid[algeb_var.name] = algeb_var.uid
 
     # initialize injections
     for elm in grid.get_injection_devices_iter():
@@ -290,8 +297,10 @@ def initialize_rms(grid: MultiCircuit, power_flow_results, logger: Logger = Logg
 
         for state_var in elm.rms_model.model.state_vars:
             vars2device[state_var.uid] = elm
+            vars_glob_name2uid[state_var.name] = state_var.uid
         for algeb_var in elm.rms_model.model.algebraic_vars:
             vars2device[algeb_var.uid] = elm
+            vars_glob_name2uid[algeb_var.name] = algeb_var.uid
 
     # add the nodal balance equations
     for i, elm in enumerate(grid.buses):
@@ -303,4 +312,4 @@ def initialize_rms(grid: MultiCircuit, power_flow_results, logger: Logger = Logg
                 mdl.algebraic_eqs.append(P[i])
                 mdl.algebraic_eqs.append(Q[i])
 
-    return compose_system_block(grid, power_flow_results, vars2device)
+    return compose_system_block(grid, power_flow_results, vars2device, vars_glob_name2uid)

{veragridengine-5.5.5 → veragridengine-5.5.7}/VeraGridEngine/Simulations/Rms/rms_driver.py

@@ -6,6 +6,7 @@
 import numpy as np
 import pandas as pd
 from typing import Dict
+
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 from VeraGridEngine.Utils.Symbolic import Var
 from VeraGridEngine.Utils.Symbolic.block_solver import BlockSolver
@@ -52,9 +53,11 @@ class RmsSimulationDriver(DriverTemplate):
 
         self.results = RmsResults(values= np.empty(0),
                  time_array=pd.DatetimeIndex(pd.to_datetime(np.empty(0))),
-                 stat_vars =  [],
-                 algeb_vars=[],
-                 vars2device= {})
+                 stat_vars = list(),
+                 algeb_vars=list(),
+                 uid2idx= dict(),
+                 vars_glob_name2uid= dict(),
+                 devices = [])
 
     def run(self):
         """
@@ -81,6 +84,13 @@ class RmsSimulationDriver(DriverTemplate):
         else:
             raise ValueError(f"integrator not implemented :( {self.options.integration_method}")
 
+        # TODO: Check if there is a cleaner way to get all the devices in a list
+
+        buses = [bus for bus in self.grid.get_buses()]
+        branches = [branch for branch in self.grid.get_branches_iter()]
+        injections = [injection for injection in self.grid.get_injection_devices_iter()]
+
+        devices = buses + branches + injections
 
         params_mapping: Dict = dict()
 
@@ -104,7 +114,9 @@ class RmsSimulationDriver(DriverTemplate):
                                   time_array=pd.DatetimeIndex(pd.to_datetime(t)),
                                   stat_vars=slv._state_vars,
                                   algeb_vars=slv._algebraic_vars,
-                                  vars2device=slv.vars2device)
+                                  uid2idx=slv.uid2idx_vars,
+                                  vars_glob_name2uid=slv.v_glob_name2uid,
+                                  devices = devices)
 
         self.toc()
 

{veragridengine-5.5.5 → veragridengine-5.5.7}/VeraGridEngine/Simulations/Rms/rms_results.py

@@ -7,7 +7,12 @@ import numpy as np
 import pandas as pd
 from matplotlib import pyplot as plt
 import matplotlib.colors as plt_colors
-from typing import List, Tuple, Dict
+from typing import List, Tuple, Dict, Union
+
+# from VeraGrid.Gui.rms_plot_variables_dialog import RmsPlotDialog
+from VeraGridEngine.Devices.Substation.bus import Bus
+from VeraGridEngine.Devices.Parents.branch_parent import BranchParent
+from VeraGridEngine.Devices.Parents.injection_parent import InjectionParent
 
 from VeraGridEngine.Devices.Parents.physical_device import PhysicalDevice
 from VeraGridEngine.Simulations.results_table import ResultsTable
@@ -25,29 +30,32 @@ class RmsResults(ResultsTemplate):
                  time_array: DateVec,
                  stat_vars: List[Var],
                  algeb_vars: List[Var],
-                 vars2device: Dict[int, PhysicalDevice],
+                 uid2idx: Dict[int, int],
+                 vars_glob_name2uid: Dict[str, int],
+                 devices: List[Union[Bus, BranchParent, InjectionParent]],
                  units: str = "",
                  ):
         ResultsTemplate.__init__(
             self,
             name='RMS simulation',
-            available_results=[ResultTypes.RmsSimulationReport],
+            available_results=[ResultTypes.RmsSimulationReport, ResultTypes.RmsPlotResults],
             time_array=time_array,
             clustering_results=None,
             study_results_type=StudyResultsType.RmsSimulation
         )
 
-        # if values.shape[1] != len(stat_vars) + len(algeb_vars):
-        #     raise ValueError("Number of columns in values must match number of variable_names")
         variables = stat_vars + algeb_vars
-        variable_names = [str(var) + vars2device[var.uid].name for var in variables]
-
+        variable_names = [str(var) for var in variables]
+        self.devices = devices
+        self.uid2idx = uid2idx
+        self.vars_glob_name2uid = vars_glob_name2uid
         self.variable_array = np.array(variable_names, dtype=np.str_)
 
         self.values = values
         self.units = units
         self.register(name='values', tpe=Vec)
 
+
     def mdl(self, result_type: ResultTypes) -> ResultsTable:
         """
         Export the results as a ResultsTable for plotting.
@@ -62,15 +70,32 @@ class RmsResults(ResultsTemplate):
                 idx_device_type=DeviceType.TimeDevice,
                 cols_device_type=DeviceType.NoDevice
             )
-        else:
-            raise Exception(f"Result type not understood: {result_type}")
+        elif result_type == ResultTypes.RmsPlotResults:
+
+            results_table = ResultsTable(
+                data=np.array(self.values),
+                index=np.array(pd.to_datetime(self.time_array).astype(str), dtype=np.str_),
+                columns=self.variable_array,
+                title="Rms Simulation Results",
+                units=self.units,
+                idx_device_type=DeviceType.TimeDevice,
+                cols_device_type=DeviceType.NoDevice,
+                xlabel=" time (s)",
+                ylabel="",
+            )
 
-    # def add(self, dt: float, y: Vec):
-    #     """
-    #
-    #     :param dt:
-    #     :param y:
-    #     :return:
-    #     """
-    #     self.dt.append(dt)
-    #     self.y.append(y)
+            devices_options = {
+            }
+
+            for device in self.devices:
+                vars_list = []
+                for var in device.rms_model.model.state_vars + device.rms_model.model.algebraic_vars:
+                    var_glob_name = next((varname for varname, uid in self.vars_glob_name2uid.items() if uid == var.uid), None)
+                    vars_list.append(var_glob_name)
+                devices_options[device.name] = vars_list
+
+            # dlg = RmsPlotDialog(devices_options, results_table, self.uid2idx, self.vars_glob_name2uid)
+            # dlg.exec()
+
+        else:
+            raise Exception(f"Result type not understood: {result_type}")

{veragridengine-5.5.5 → veragridengine-5.5.7}/VeraGridEngine/Simulations/SmallSignalStability/small_signal_driver.py

@@ -7,9 +7,7 @@ import numpy as np
 import numba as nb
 from matplotlib import pyplot as plt
 import scipy.linalg
-from scipy.sparse import csr_matrix, csc_matrix, lil_matrix
 from scipy.sparse.linalg import spsolve
-import scipy.sparse as sp
 import math
 
 from typing import Dict, Union
@@ -25,6 +23,29 @@ from VeraGridEngine.basic_structures import Vec
 from VeraGridEngine.enumerations import  ResultTypes
 
 
+def compute_state_matrix(slv: BlockSolver, x: Vec, params: Vec,):
+    """
+    Small Signal Stability analysis
+    :param slv: BlockSolver
+    :param x: variables (1D numpy array)
+    :param params: parameters (1D numpy array)
+
+    :return: np array state matrix(A)
+
+    Small Signal Stability analysis:
+    1. Calculate the state matrix (A) from the state space model. From the semi-explicit DAE model:
+        Tx'=f(x,y)
+        0=g(x,y)
+        the A matrix is computed as:
+        A = T^-1(f_x - f_y * g_y^{-1} * g_x)   #T is implicit in the jacobian!
+    """
+    fx = slv.j11(x, params)  # ∂f/∂x
+    fy = slv.j12(x, params)  # ∂f/∂y
+    gx = slv.j21(x, params)  # ∂g/∂x
+    gy = slv.j22(x, params)  # ∂g/∂y
+
+    gyx = spsolve(gy, gx)
+    return fx - fy @ gyx
 
 @nb.njit(cache=True)
 def compute_participation_factors(An, Am, v, w, n_eigenvalues, num_states):
@@ -43,7 +64,6 @@ def compute_participation_factors(An, Am, v, w, n_eigenvalues, num_states):
             participation_factors[row, column] = abs(w[row, column]) * abs(v[row, column])
 
     # normalize participation factors
-    # pfact_abs = sp.csc_matrix(np.ones(num_states)) @ participation_factors
     pfact_abs = np.ones(num_states) @ participation_factors
     for i in range(n_eigenvalues):
         participation_factors[:, i] /= pfact_abs[i]
@@ -150,7 +170,7 @@ def plot_stability(eigenvalues, plot_units = "rad/s" ):
     plt.show()
 
 
-def run_small_signal_stability(slv: BlockSolver, x: Vec, params: Vec, plot=True, plot_units = "rad/s", verbose: int = 0):
+def run_small_signal_stability(slv: BlockSolver, x: Vec, params: Vec, verbose: int = 0):
     """
     Small Signal Stability analysis
     :param slv: BlockSolver
@@ -164,11 +184,9 @@ def run_small_signal_stability(slv: BlockSolver, x: Vec, params: Vec, plot=True,
         eigenvalues:  1D row numpy array
         participation factors: 2D array csc matrix.
             Participation factors of mode i stored in PF[:,i]
-    """
 
-    """
     Small Signal Stability analysis:
-    1. Calculate the state matrix (A) from the state space model. From the DAE model:
+    1. Calculate the state matrix (A) from the state space model. From the semi-explicit DAE model:
         Tx'=f(x,y)
         0=g(x,y)
         the A matrix is computed as:
@@ -176,22 +194,17 @@ def run_small_signal_stability(slv: BlockSolver, x: Vec, params: Vec, plot=True,
 
     2. Find eigenvalues and right(V) and left(W) eigenvectors
 
-    3. Perform stability assessment
+    3. Calculate normalized participation factors PF = W · V
 
-    4. Calculate normalized participation factors PF = W · V
+    4. Calculate damping ratios and oscillation frequencies of the complex conjugate poles
     """
-
-    fx = slv.j11(x, params)  # ∂f/∂x
-    fy = slv.j12(x, params)  # ∂f/∂y
-    gx = slv.j21(x, params)  # ∂g/∂x
-    gy = slv.j22(x, params)  # ∂g/∂y
-
-    gyx = spsolve(gy, gx)
-    A = (fx - fy @ gyx)  # sparse state matrix csc matrix
+    A = compute_state_matrix(slv,
+                             x,
+                             params) # sparse state matrix csc matrix
     num_states = A.shape[0]
 
     # Note: The eigenvalue solution is dense in practice and apparently there is no sparse way around it
-    eigenvalues, w, v = scipy.linalg.eig(A.toarray(), left=True, right=True) # TODO: always use sparse algebra
+    eigenvalues, w, v = scipy.linalg.eig(A.toarray(), left=True, right=True)
 
     # find participation factors
     participation_factors = compute_participation_factors(An=A.shape[0],
@@ -207,32 +220,15 @@ def run_small_signal_stability(slv: BlockSolver, x: Vec, params: Vec, plot=True,
     damping_ratios, conjugate_freq = compute_damping_ratios_and_frequencies(eigenvalues = eigenvalues,
                                                                                    eig_no_conjugates = eig_no_conjugates)
 
-    # Stability: select positive and zero eigenvalues
-    tol = 1e-6  # numerical tolerance for eigenvalues = 0
-    unstable_eigs = eigenvalues[np.real(eigenvalues) > tol]
-    zero_eigs = eigenvalues[abs(np.real(eigenvalues)) <= tol]
-
-    if unstable_eigs.size == 0:
-        if zero_eigs.size == 0:
-            stability_report = ResultTypes.AsymptoticallyStable
-        else:
-            stability_report = ResultTypes.MarginallyStable
-    else:
-        stability_report = ResultTypes.Unstable
-
-    if plot:
-        plot_stability(eigenvalues = eigenvalues,
-                       plot_units= plot_units)
-
     if verbose:
-        print("Stability report:", stability_report)
+        print("State matrix:", A.toarray())
         print("Eigenvalues:", eigenvalues)
-        print("eig no conjugates:", eig_no_conjugates)
+        print("Participation factors:", participation_factors)
         print("Daming ratios:", [str(r) if not np.isnan(r) else '-' for r in damping_ratios])
         print("Oscillation frequencies[Hz]:", [str(r) if not np.isnan(r) else '-' for r in conjugate_freq])
-        print("Participation factors:", participation_factors)
 
-    return stability_report, eigenvalues, participation_factors, damping_ratios, conjugate_freq
+
+    return eigenvalues, participation_factors, damping_ratios, conjugate_freq, A.toarray()
 
 
 class SmallSignalStabilityDriver(DriverTemplate):
@@ -263,11 +259,11 @@ class SmallSignalStabilityDriver(DriverTemplate):
 
         self.options: SmallSignalStabilityOptions = SmallSignalStabilityOptions() if options is None else options
 
-        self.results: SmallSignalStabilityResults = SmallSignalStabilityResults(stability="",
-                                                                                eigenvalues=np.empty(0),
+        self.results: SmallSignalStabilityResults = SmallSignalStabilityResults(eigenvalues=np.empty(0),
                                                                                 participation_factors=np.empty(0),
                                                                                 damping_ratios=np.empty(0),
                                                                                 conjugate_frequencies=np.empty(0),
+                                                                                state_matrix =np.empty(0),
                                                                                 stat_vars=[],
                                                                                 vars2device={})
 
@@ -318,26 +314,26 @@ class SmallSignalStabilityDriver(DriverTemplate):
             )
 
             i = int(self.options.ss_assessment_time / self.options.time_step)
-            (stability,
-             eigenvalues,
+            (eigenvalues,
              participation_factors,
              damping_ratios,
-             conjugate_frequencies) = run_small_signal_stability(slv=slv, x=y[i], params=params0, plot=False)
+             conjugate_frequencies,
+             state_matrix) = run_small_signal_stability(slv=slv, x=y[i], params=params0)
 
         else:
 
-            (stability,
-             eigenvalues,
+            (eigenvalues,
              participation_factors,
              damping_ratios,
-             conjugate_frequencies) = run_small_signal_stability(slv=slv, x=x0, params=params0, plot=False)
+             conjugate_frequencies,
+             state_matrix) = run_small_signal_stability(slv=slv, x=x0, params=params0)
 
         self.results: SmallSignalStabilityResults = SmallSignalStabilityResults(
-            stability = stability,
             eigenvalues = eigenvalues,
             participation_factors = participation_factors,
             damping_ratios = damping_ratios,
             conjugate_frequencies = conjugate_frequencies,
+            state_matrix = state_matrix,
             stat_vars = slv.state_vars,
             vars2device = slv.vars2device
         )

{veragridengine-5.5.5 → veragridengine-5.5.7}/VeraGridEngine/Simulations/SmallSignalStability/small_signal_results.py

@@ -19,11 +19,11 @@ from VeraGridEngine.Utils.Symbolic.symbolic import Var
 class SmallSignalStabilityResults(ResultsTemplate):
 
     def __init__(self,
-                 stability: str,
                  eigenvalues: np.ndarray,
                  participation_factors: np.ndarray,
                  damping_ratios: np.ndarray,
                  conjugate_frequencies: np.ndarray,
+                 state_matrix: np.array,
                  stat_vars: List[Var],
                  vars2device: Dict[int, PhysicalDevice]):
         """
@@ -40,6 +40,7 @@ class SmallSignalStabilityResults(ResultsTemplate):
             self,
             name='Small Signal Stability',
             available_results=[
+                ResultTypes.StateMatrix,
                 ResultTypes.Modes,
                 ResultTypes.ParticipationFactors,
                 ResultTypes.SDomainPlot,
@@ -54,28 +55,39 @@ class SmallSignalStabilityResults(ResultsTemplate):
 
         self.stat_vars_array = np.array(stat_vars_names, dtype=np.str_)
 
-        self.stability = stability
         self.eigenvalues = eigenvalues
         self.participation_factors = participation_factors
         self.damping_ratios = [str(r) if not np.isnan(r) else '-' for r in damping_ratios]
         self.conjugate_frequencies = [str(r) if not np.isnan(r) else '-' for r in conjugate_frequencies]
+        self.state_matrix = state_matrix
 
-        # self.register(name='Stability', tpe=Vec)
         self.register(name='eigenvalues', tpe=Vec)
         self.register(name='participation_factors', tpe=Vec)
         self.register(name='damping_ratios', tpe=Vec)
         self.register(name='conjugate_frequencies', tpe=Vec)
+        self.register(name='state_matrix', tpe=Vec)
 
     def mdl(self, result_type: ResultTypes) -> ResultsTable:
         """
         Export the results as a ResultsTable for plotting.
         """
+        if result_type == ResultTypes.StateMatrix:
+
+            return ResultsTable(
+                data=self.state_matrix,
+                index=np.array([f"Equation {i}" for i in range(len(self.eigenvalues))], dtype=np.str_),
+                columns=np.array(self.stat_vars_array.astype(str), dtype=np.str_),
+                title="State Matrix",
+                idx_device_type=DeviceType.NoDevice,
+                cols_device_type=DeviceType.NoDevice
+            )
+
         if result_type == ResultTypes.ParticipationFactors:
 
             return ResultsTable(
                 data=self.participation_factors,
                 index=np.array(self.stat_vars_array.astype(str), dtype=np.str_),
-                columns=np.array([f"Mode {i}" for i in range(len(self.eigenvalues))], dtype=np.str_),  #
+                columns=np.array([f"Mode {i}" for i in range(len(self.eigenvalues))], dtype=np.str_),
                 title="Participation factors for each eigenvalue",
                 idx_device_type=DeviceType.NoDevice,
                 cols_device_type=DeviceType.NoDevice
@@ -99,7 +111,7 @@ class SmallSignalStabilityResults(ResultsTemplate):
             data = np.c_[re, im]
 
             d = np.abs(np.nan_to_num(re))
-            colors = (d / d.max())
+            colors = (-d / d.max())
 
             slope = 1 / 0.05
             x_z = np.linspace(-200, 0, 400)
@@ -122,7 +134,7 @@ class SmallSignalStabilityResults(ResultsTemplate):
                 sc = ax.scatter(re, im, c=colors, cmap='winter', s=120, alpha=0.8)
                 fig.suptitle("S-Domain Stability plot")
                 ax.set_xlabel(r'Real')
-                ax.set_ylabel(r'Imaginary [rad]')
+                ax.set_ylabel(r'Imaginary [rad/s]')
                 ax.axhline(0, color='black', linewidth=1)  # eje horizontal (y = 0)
                 ax.axvline(0, color='black', linewidth=1)
                 plt.xlim([x_min, x_max])
@@ -174,7 +186,7 @@ class SmallSignalStabilityResults(ResultsTemplate):
             data = np.c_[re, im]
 
             d = np.abs(np.nan_to_num(re))
-            colors = (d / d.max())
+            colors = (-d / d.max())
 
             slope = 1 / 0.05
             x_z = np.linspace(-200, 0, 400)
@@ -245,22 +257,3 @@ class SmallSignalStabilityResults(ResultsTemplate):
                                 )
         else:
             raise Exception(f"Result type not understood: {result_type}")
-
-    # def plot(self, fig, ax):
-    #     """
-    #     Plot the S-Domain modes plot
-    #     :param fig: Matplotlib figure. If None, one will be created
-    #     :param ax: Matplotlib Axis. If None, one will be created
-    #     """
-    #     if ax is None:
-    #         fig = plt.figure(figsize=(8, 7))
-    #         ax = fig.add_subplot(111)
-    #
-    #     x = self.eigenvalues.real
-    #     y = self.eigenvalues.imag
-    #
-    #     ax.scatter(x, y, 'k', linewidth=2)
-    #
-    #     ax.set_title(r'$S-Domain$ plot')
-    #     ax.set_xlabel(r'$Imaginary [s^{-1}]$')
-    #     ax.set_ylabel(r'$Real [s^{-1}]$')