VeraGridEngine.Simulations.ContingencyAnalysis.Methods package

Submodules

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.helm_contingencies module

class VeraGridEngine.Simulations.ContingencyAnalysis.Methods.helm_contingencies.HelmVariations(numerical_circuit: NumericalCircuit)

Bases: object

Class to quickly evaluate topological variations based on HELM coefficients

compute_variations(contingency_br_indices: ndarray[tuple[Any, ...], dtype[int64]]) → Tuple[ndarray[tuple[Any, ...], dtype[complex128]], ndarray[tuple[Any, ...], dtype[complex128]], ndarray[tuple[Any, ...], dtype[complex128]]]

Compute a branch contingency :param contingency_br_indices: array of branch indices to fail :return: V, Sf, loading

initialize()

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.helm_contingencies.calc_V_outage(nc: NumericalCircuit, If: ndarray[tuple[Any, ...], dtype[complex128]], Ybus: csc_matrix, Yf: csc_matrix, sys_mat_factorization, V0: ndarray[tuple[Any, ...], dtype[complex128]], S0: ndarray[tuple[Any, ...], dtype[complex128]], Uini, Xini, Yslack, Vslack, vec_P, vec_Q, Ysh, vec_W, pq: ndarray[tuple[Any, ...], dtype[int64]], pv: ndarray[tuple[Any, ...], dtype[int64]], vd: ndarray[tuple[Any, ...], dtype[int64]], pqpv: ndarray[tuple[Any, ...], dtype[int64]], pqpv_original: ndarray[tuple[Any, ...], dtype[int64]], pq_original: ndarray[tuple[Any, ...], dtype[int64]], contingency_br_indices: ndarray[tuple[Any, ...], dtype[int64]])

Calculate the voltage due to outages in a non-linear manner with HELM. The main novelty is the introduction of s.AY, thus delaying it Use directly V from HELM, do not go for Pade, may need more time for not much benefit :param nc: NumericalCircuit instance :param If: from currents of the initial power flow :param Ybus: original admittance matrix

Parameters:

• sys_mat_factorization

• V0 – initial voltage array

• S0 – vector of powers

• Uini

• Xini

• Yslack

• Vslack

• vec_P

• vec_Q

• Ysh – array of shunt admittances

• vec_W

• pq – set of PQ buses

• pv – set of PV buses

• vd – set of slack buses

• pqpv – set of PQ + PV buses

• pqpv_original – set of PQ + PV buses in the original order

• pq_original – set of PQ buses in the original order, considering slack

• contingency_br_indices – array of branch indices of the contingency

Returns:

V, Sf, loading, norm_f

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.helm_contingency_analysis module

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.helm_contingency_analysis.helm_contingency_analysis(grid: MultiCircuit, options: ContingencyAnalysisOptions, calling_class, opf_results: VALID_OPF_RESULTS | None = None, t: int | None = None, t_prob: float = 1.0) → ContingencyAnalysisResults

Run N-1 simulation in series with HELM, non-linear solution :param grid: :param options: :param calling_class: :param opf_results: OPF results, to be used if not None :param t: time index, if None the snapshot is used :param t_prob: probability of te time :return: returns the results

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.linear_contingency_analysis module

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.linear_contingency_analysis.linear_contingency_analysis(nc: NumericalCircuit, options: ContingencyAnalysisOptions, linear_analysis: LinearAnalysis, linear_multiple_contingencies: LinearMultiContingencies, area_names: ndarray[tuple[Any, ...], dtype[str_]] | List[str], bus_area_indices: ndarray[tuple[Any, ...], dtype[int64]], F: ndarray[tuple[Any, ...], dtype[int64]], T: ndarray[tuple[Any, ...], dtype[int64]], report_text: Callable[[str], None] | None, report_progress2: Callable[[int, int], None] | None, is_cancel: Callable[[], bool] | None, t: int | None = None, t_prob=1.0, logger: Logger | None = None) → ContingencyAnalysisResults

Run N-1 simulation in series with HELM, non-linear solution :param nc: NumericalCircuit :param options: ContingencyAnalysisOptions :param linear_analysis: LinearAnalysis :param linear_multiple_contingencies: LinearMultiContingencies :param area_names: :param bus_area_indices: :param F: :param T: :param report_text: :param report_progress2; :param is_cancel: :param t: time index, if None the snapshot is used :param t_prob: probability of te time :param logger: logger instance :return: returns the results

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.linear_contingency_analysis.linear_contingency_analysis_old(nc: NumericalCircuit, options: ContingencyAnalysisOptions, linear_multiple_contingencies: LinearMultiContingencies, area_names: ndarray[tuple[Any, ...], dtype[str_]] | List[str], bus_area_indices: ndarray[tuple[Any, ...], dtype[int64]], F: ndarray[tuple[Any, ...], dtype[int64]], T: ndarray[tuple[Any, ...], dtype[int64]], report_text: Callable[[str], None] | None, report_progress2: Callable[[int, int], None] | None, is_cancel: Callable[[], bool] | None, t: int | None = None, t_prob=1.0, logger: Logger | None = None) → ContingencyAnalysisResults

Run N-1 simulation in series with HELM, non-linear solution :param nc: NumericalCircuit :param options: ContingencyAnalysisOptions :param linear_multiple_contingencies: LinearMultiContingencies :param area_names: :param bus_area_indices: :param F: :param T: :param report_text: :param report_progress2; :param is_cancel: :param t: time index, if None the snapshot is used :param t_prob: probability of te time :param logger: logger instance :return: returns the results

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.linear_contingency_analysis.linear_contingency_scan_numba(nbr: int, n_con_groups: int, Pbus: ndarray[tuple[Any, ...], dtype[float64]], rates: ndarray[tuple[Any, ...], dtype[float64]], con_rates: ndarray[tuple[Any, ...], dtype[float64]], PTDF: ndarray[tuple[Any, ...], dtype[float64]] | ndarray[tuple[int, int], dtype[float64]], LODF: ndarray[tuple[Any, ...], dtype[float64]] | ndarray[tuple[int, int], dtype[float64]], mon_idx: ndarray[tuple[Any, ...], dtype[int64]], single_con_br_idx: ndarray[tuple[Any, ...], dtype[int64]], single_con_cg_idx: ndarray[tuple[Any, ...], dtype[int64]])

Fast contingency scan using the PTDF :param nbr: Number of branches :param n_con_groups: Number of contingency groups :param Pbus: Buses injection (nbus, in MW) :param rates: Rates vector (nbr) :param con_rates: Contingency rates vector (nbr) :param PTDF: PTDF matrix (nbr, nbus) :param LODF: LODF matrix (nbr, nbr) :param mon_idx: Monitored branches :param single_con_br_idx: array of single contingency branch indices :param single_con_cg_idx: array of the matching contingency groups :return: SbrCon(nconn, nbr), LoadingCon(nconn, nbr), problems(…, (m, c))

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.nonlinear_contingency_analysis module

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.nonlinear_contingency_analysis.nonlinear_contingency_analysis(nc: NumericalCircuit, options: ContingencyAnalysisOptions, linear_multiple_contingencies: LinearMultiContingencies, area_names: ndarray[tuple[Any, ...], dtype[str_]] | List[str], bus_area_indices: ndarray[tuple[Any, ...], dtype[int64]], F: ndarray[tuple[Any, ...], dtype[int64]], T: ndarray[tuple[Any, ...], dtype[int64]], report_text: Callable[[str], None] | None, report_progress2: Callable[[int, int], None] | None, is_cancel: Callable[[], bool] | None, t_idx: None | int = None, t_prob: float = 1.0, logger: Logger | None = None) → ContingencyAnalysisResults

Run a contingency analysis using the power flow options :param nc: NumericalCircuit :param options: ContingencyAnalysisOptions :param linear_multiple_contingencies: LinearMultiContingencies :param area_names: :param bus_area_indices: :param F: :param T: :param report_text: :param report_progress2; :param is_cancel: :param t_idx: time index, if None the snapshot is used :param t_prob: probability of te time :param logger: logger instance :return: returns the results

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.optimal_linear_contingency_analysis module

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.optimal_linear_contingency_analysis.optimal_linear_contingency_analysis(grid: MultiCircuit, options: ContingencyAnalysisOptions, opf_options: OptimalPowerFlowOptions, linear_multiple_contingencies: LinearMultiContingencies, calling_class: ContingencyAnalysisDriver, t: Union[None, int]=None, t_prob: float = 1.0, logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → ContingencyAnalysisResults

Run N-1 simulation in series with HELM, non-linear solution :param grid: MultiCircuit :param options: ContingencyAnalysisOptions :param opf_options: OptimalPowerFlowOptions :param linear_multiple_contingencies: LinearMultiContingencies :param calling_class: ContingencyAnalysisDriver :param t: time index, if None the snapshot is used :param t_prob: probability of te time :param logger: Logger object :return: returns the results

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.srap module

class VeraGridEngine.Simulations.ContingencyAnalysis.Methods.srap.BusesForSrap(branch_idx: int, bus_indices: ndarray[tuple[Any, ...], dtype[int64]], sensitivities: ndarray[tuple[Any, ...], dtype[float64]])

Bases: object

Buses information for SRAP over a particular branch

is_solvable(c_flow: float, rating: float, srap_pmax_mw: float, available_power: ndarray[tuple[Any, ...], dtype[float64]], srap_used_power: ndarray[tuple[Any, ...], dtype[float64]] | ndarray[tuple[int, int], dtype[float64]], branch_idx: int, top_n: int = 1000) → Tuple[bool, float]

Get the maximum amount of power (MW) to dispatch using SRAP :param c_flow: Contingency flow (MW) :param rating: Branch rating (MVA) :param srap_pmax_mw: SRAP limit in MW :param available_power: Array of available power per bus :param srap_used_power: Matrix including power used in SRAP (nbranch,nbus) :param branch_idx: overloaded branch index :param top_n: maximum number of nodes affecting the overload :return: min(srap_limit, sum(p_available))

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.srap.get_valid_negatives(sensitivities: ndarray[tuple[Any, ...], dtype[float64]], p_available: ndarray[tuple[Any, ...], dtype[float64]])

Parameters:

• sensitivities

• p_available

Returns:

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.srap.get_valid_positives(sensitivities: ndarray[tuple[Any, ...], dtype[float64]], p_available: ndarray[tuple[Any, ...], dtype[float64]])

Parameters:

• sensitivities

• p_available

Returns:

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.srap.vector_sum_srap(p_available3: ndarray[tuple[Any, ...], dtype[float64]], sensitivities3: ndarray[tuple[Any, ...], dtype[float64]], srap_pmax_mw: float)

Parameters:

• p_available3

• sensitivities3

• srap_pmax_mw

Returns:

VeraGridEngine.Simulations.ContingencyAnalysis.Methods.srap.vector_sum_used_power_srap(p_available3: ndarray[tuple[Any, ...], dtype[float64]], sensitivities3: ndarray[tuple[Any, ...], dtype[float64]], max_srap_power: float)

Parameters:

• p_available3

• sensitivities3

• max_srap_power

Returns:

Module contents