VeraGridEngine.Simulations.Rms package

Subpackages

Submodules

VeraGridEngine.Simulations.Rms.initialization module

class VeraGridEngine.Simulations.Rms.initialization.PseudoTransientInitProblem(block: Block, x_global: ndarray[tuple[Any, ...], dtype[float64]], compiler_names_dict: Dict[int, str], alias_names_dict: Dict[int, str], uid2idx_vars: Dict[int, int], variable_parameters: List[Var], constant_parameters: List[Var], VARS_NAME: str = 'vars', DIFF_NAME: str = 'diff', VARIABLE_PARAMS_NAME: str = 'vprms', CONSTANT_PARAMS_NAME: str = 'cprms')[source]

Bases: object

Lightweight problem class for pseudo-transient initialization of a single device block. Similar interface to RmsProblemDae but for initialization only.

algebraic_vars()[source]
find_feasible_point(x0: ndarray[tuple[Any, ...], dtype[float64]], max_steps: int = 2000, tol: float = 0.0001, alpha: float = 1.0, h_jac: float = 0.001) → ndarray[tuple[Any, ...], dtype[float64]][source]

Project initial guess to algebraic feasible manifold g(x, y)=0.

Keeps state variables fixed and updates algebraic variables with LSQR.

find_feasible_point_joint(x0: ndarray[tuple[Any, ...], dtype[float64]], free_state_names: tuple[str, ...] = ('delta', 'omega'), max_steps: int = 200, tol: float = 1e-05, h_jac: float = 0.001) → ndarray[tuple[Any, ...], dtype[float64]][source]

Joint feasibility projection on algebraics plus selected states.

Solves a reduced nonlinear system using variables: - all algebraic variables - selected state variables (name contains tokens in free_state_names)

find_feasible_point_staged(x0: ndarray[tuple[Any, ...], dtype[float64]], max_steps_stage: int = 120, tol_stage1: float = 0.0001, tol_stage2: float = 1e-05, h_jac: float = 0.001) → ndarray[tuple[Any, ...], dtype[float64]][source]

Staged feasibility: first network subset, then full joint system.

get_algebraic_var_number() → int[source]
get_algebraic_vars()[source]
get_all_vars_number() → int[source]
get_diff_var_number() → int[source]
get_dx(x: ndarray[tuple[Any, ...], dtype[float64]], xn: ndarray[tuple[Any, ...], dtype[float64]], dx: ndarray[tuple[Any, ...], dtype[float64]], h: float) → ndarray[tuple[Any, ...], dtype[float64]][source]

Compute derivatives.

get_j11(x: ndarray[tuple[Any, ...], dtype[float64]], dx: ndarray[tuple[Any, ...], dtype[float64]], h: float) → csc_matrix[source]

Jacobian of state equations w.r.t. state variables.

get_j12(x: ndarray[tuple[Any, ...], dtype[float64]], dx: ndarray[tuple[Any, ...], dtype[float64]], h: float) → csc_matrix[source]

Jacobian of state equations w.r.t. algebraic variables.

get_j21(x: ndarray[tuple[Any, ...], dtype[float64]], dx: ndarray[tuple[Any, ...], dtype[float64]], h: float) → csc_matrix[source]

Jacobian of algebraic equations w.r.t. state variables.

get_j22(x: ndarray[tuple[Any, ...], dtype[float64]], dx: ndarray[tuple[Any, ...], dtype[float64]], h: float) → csc_matrix[source]

Jacobian of algebraic equations w.r.t. algebraic variables.

get_states_number() → int[source]
rhs_algebraic(x: ndarray[tuple[Any, ...], dtype[float64]], dx: ndarray[tuple[Any, ...], dtype[float64]]) → ndarray[tuple[Any, ...], dtype[float64]][source]

Evaluate RHS for algebraic equations.

rhs_state(x: ndarray[tuple[Any, ...], dtype[float64]], dx: ndarray[tuple[Any, ...], dtype[float64]]) → ndarray[tuple[Any, ...], dtype[float64]][source]

Evaluate RHS for state equations.

state_vars()[source]
property uid2idx_vars
update_variable_params(t: float)[source]

Update variable parameters at time t.

VeraGridEngine.Simulations.Rms.initialization.add_items(blk, init_vars, init_event)[source]

adds items from a block to the dictionary :param blk: :type blk: :param init_vars: :param init_event: init_dict :return: :rtype:

VeraGridEngine.Simulations.Rms.initialization.build_init_dict(mdl, init_vars, init_event)[source]

builds initialization dictionary from mdl :param mdl: :type mdl: :param init_vars: :param init_event: :type init_vars: init_dict :return: :rtype:

VeraGridEngine.Simulations.Rms.initialization.build_init_vars_vector(uid2idx_vars, mapping: dict[Var, float]) → ndarray[source]

Helper function to build the initial vector :param uid2idx_vars: :param mapping: var->initial value mapping :return: array matching with the mapping, matching the solver ordering

VeraGridEngine.Simulations.Rms.initialization.init_custom(mdl, init_guess)[source]
VeraGridEngine.Simulations.Rms.initialization.init_explicit(mdl: Block, sys_vars: Dict[int, Var], variable_parameters: List[Var], event_parameters_eqs: List[Expr | Const], constant_parameters: List[Var], init_guess: Dict[int, float], uid2idx_vars: Dict[int, int], uid2idx_params: Dict[int, int], uid2idx_event_params: Dict[int, int], compiler_names_dict: Dict[int, str], alias_names_dict: Dict[int, str], VARIABLE_PARAMS_NAME: str, TIME_NAME: str, VARS_NAME: str, DIFF_NAME: str, CONSTANT_PARAMS_NAME: str)[source]

initialize model using explicit equations

Parameters:
Returns:

Return type:

Union[None, Tuple[Dict[Tuple[int, str], float], VeraGridEngine.Utils.Symbolic.block.Block]]

VeraGridEngine.Simulations.Rms.initialization.init_pseudo_transient(mdl: Block, sys_vars: Dict[int, Var], variable_parameters: List[Var], event_parameters_eqs: List[Expr | Const], constant_parameters: List[Var], init_guess: Dict[int, float], uid2idx_vars: Dict[int, int], uid2idx_params: Dict[int, int], uid2idx_event_params: Dict[int, int], compiler_names_dict: Dict[int, str], alias_names_dict: Dict[int, str], VARIABLE_PARAMS_NAME: str, TIME_NAME: str, VARS_NAME: str, DIFF_NAME: str, CONSTANT_PARAMS_NAME: str, dtau0: float = 0.001, max_iter: int = 100, tol: float = 1e-06, verbose: bool = False)[source]

Initialize model using pseudo-transient method.

Similar interface to init_explicit but uses pseudo-transient simulation instead of explicit equation evaluation.

VeraGridEngine.Simulations.Rms.initialization.solve_newton(eq_fn, x, idx, event_params_array, params_array, dummy_diff, tol=1e-08, max_iter=20, h=1e-06)[source]
VeraGridEngine.Simulations.Rms.initialization.solve_secant(eq_fn, x, idx, event_params_array, params_array, tol=1e-08, max_iter=50, seed: float | None = None, fallback_seed: float = 10.0)[source]

VeraGridEngine.Simulations.Rms.initialization_rms module

class VeraGridEngine.Simulations.Rms.initialization_rms.EmtInitializationReport(method_requested: EmtInitializationMethod)[source]

Bases: object

Stores the outcome of the EMT-native initialization workflow.

automatic_dx0_count: int
constant_param_build_s: float
dx0_completion_s: float
dx0_seed_build_s: float
elapsed_s: float
final_residual_inf: float
initial_residual_eval_s: float
initial_residual_inf: float
message: str
method_requested: EmtInitializationMethod
method_used: EmtInitializationMethod
missing_dx_problem_collect_s: float
missing_dx_scatter_s: float
newton_elapsed_s: float
newton_iterations: int
persistent_cache_hit: bool
persistent_cache_load_s: float
persistent_cache_store_s: float
pseudo_transient_elapsed_s: float
pseudo_transient_steps: int
reduced_system_build_s: float
runtime_param_build_s: float
solution_apply_s: float
state_rhs_eval_s: float
state_rhs_vector_build_s: float
state_rhs_vector_cache_hit: bool
status: EmtInitializationStatus
unknown_var_count: int
unresolved_state_count: int
x0_rebuild_s: float
class VeraGridEngine.Simulations.Rms.initialization_rms.InitializationStateRhsVector(source_code: str, use_jit: bool, output_size: int)[source]

Bases: object

Lightweight state-RHS evaluator used by dx0 completion.

class VeraGridEngine.Simulations.Rms.initialization_rms.InitializationVectorCache[source]

Bases: object

In-process cache for symbolic vectors used during EMT initialization.

get_entry(cache_key: str) → InitializationVectorCacheEntry | None[source]

Return one cached initialization-vector entry.

Parameters:

cache_key (str) – Deterministic cache key.

Returns:

Cached entry or None.

Return type:

InitializationVectorCacheEntry | None

set_entry(cache_key: str, entry: InitializationVectorCacheEntry) → None[source]

Store one cached initialization-vector entry.

Parameters:
Returns:

None.

Return type:

None

class VeraGridEngine.Simulations.Rms.initialization_rms.InitializationVectorCacheEntry(vector: SymbolicVector)[source]

Bases: object

In-process cache entry for one initialization-stage symbolic vector.

get_vector() → SymbolicVector[source]

Return the cached symbolic vector evaluator.

Returns:

Cached symbolic vector evaluator.

Return type:

SymbolicVector

class VeraGridEngine.Simulations.Rms.initialization_rms.ReducedInitializationSystem(problem: Any, unknowns: List[Var], unknown_vars: List[Var], unknown_events: List[Var], residual_eqs: List[Expr], state_unknown_mask: ndarray)[source]

Bases: object

Reduced RMS initialization system built on top of the unresolved variables only.

jacobian_fn
residual_eqs
residual_fn
state_unknown_mask
unknown_events
unknown_vars
unknowns
class VeraGridEngine.Simulations.Rms.initialization_rms.ReducedInitializationSystemCache[source]

Bases: object

In-process cache for reduced EMT initialization systems.

get_entry(cache_key: str) → ReducedInitializationSystemCacheEntry | None[source]

Return one cached reduced-system entry.

Parameters:

cache_key (str) – Deterministic cache key.

Returns:

Cached entry or None.

Return type:

ReducedInitializationSystemCacheEntry | None

set_entry(cache_key: str, entry: ReducedInitializationSystemCacheEntry) → None[source]

Store one cached reduced-system entry.

Parameters:
Returns:

None.

Return type:

None

class VeraGridEngine.Simulations.Rms.initialization_rms.ReducedInitializationSystemCacheEntry(residual_fn: SymbolicVector, jacobian_fn: SymbolicJacobian)[source]

Bases: object

In-process cache entry for reduced EMT initialization systems.

get_jacobian_fn() → SymbolicJacobian[source]

Return the cached reduced Jacobian evaluator.

Returns:

Reduced Jacobian evaluator.

Return type:

SymbolicJacobian

get_residual_fn() → SymbolicVector[source]

Return the cached reduced residual evaluator.

Returns:

Reduced residual evaluator.

Return type:

SymbolicVector

VeraGridEngine.Simulations.Rms.initialization_rms.apply_solution_to_problem(problem: Any, x: ndarray, event_x: ndarray) → None[source]

Persist the reduced-solve state vector back into the initialization guess map.

Parameters:

  • problem – EMT problem being initialized.

  • x – Full EMT variable vector.

Returns:

None

VeraGridEngine.Simulations.Rms.initialization_rms.build_constant_param_array(problem: Any) → ndarray[source]

Build the dense constant-parameter vector used by the initialization solvers.

Parameters:

problem – EMT problem being initialized.

Returns:

Constant-parameter array.

VeraGridEngine.Simulations.Rms.initialization_rms.build_persistent_initialization_cache_key(problem: Any, unknown_vars: List[Var], residual_eqs: List[Expr], state_unknown_mask: ndarray, options: RmsOptions) → str[source]

Return the deterministic cache key of one persistent reduced initialization result.

Parameters:

  • problem (EmtProblemTemplate) – EMT problem being initialized.

  • unknown_vars (List[Var]) – Unknown variables in the reduced system.

  • residual_eqs (List[Expr]) – Residual equations in the reduced system.

  • state_unknown_mask (np.ndarray) – Reduced state mask.

  • options (EmtOptions) – EMT initialization options.

Returns:

Deterministic cache key.

Return type:

str

VeraGridEngine.Simulations.Rms.initialization_rms.build_reduced_initialization_cache_key(problem: Any, unknown_vars: List[Var], residual_eqs: List[Expr], state_unknown_mask: ndarray) → str[source]

Return a deterministic cache key for one reduced Rms initialization system.

Parameters:

  • problem (EmtProblemTemplate) – EMT problem being initialized.

  • unknown_vars (List[Var]) – Unknown variables solved by the reduced system.

  • residual_eqs (List[Expr]) – Residual equations enforcing consistency.

  • state_unknown_mask (np.ndarray) – State-mask vector.

Returns:

Deterministic cache key.

Return type:

str

VeraGridEngine.Simulations.Rms.initialization_rms.build_reduced_initialization_system(problem: Any, allow_state_equilibrium: bool) → ReducedInitializationSystem | None[source]

Build the reduced initialization system for unresolved EMT variables.

The reduced system always enforces all algebraic equations. In addition, any state variable still missing after the explicit stage receives one extra consistency equation, either from init_eqs or from a steady-state residual.

Parameters:

  • problem – EMT problem being initialized.

  • allow_state_equilibrium – Whether unresolved states may use f(x,z,p)=0.

Returns:

Reduced initialization system or None if nothing remains to solve.

VeraGridEngine.Simulations.Rms.initialization_rms.build_runtime_param_array(problem: Any) → ndarray[source]

Build the runtime-parameter snapshot at the initialization time.

Parameters:

problem – EMT problem being initialized.

Returns:

Runtime-parameter array at time zero.

VeraGridEngine.Simulations.Rms.initialization_rms.build_state_equation_lookup(problem: Any) → Dict[int, Expr][source]

Build a UID lookup for state equations.

Parameters:

problem – EMT problem being initialized.

Returns:

Mapping from state variable UID to its differential right-hand side.

VeraGridEngine.Simulations.Rms.initialization_rms.build_uid_bindings(eq: Expr | Const, event_params_array: ndarray, x: ndarray, params_array: ndarray, dx: ndarray, uid2idx_event_params: Dict[int, int], uid2idx_vars: Dict[int, int], uid2idx_params: Dict[int, int], uid2idx_diff: Dict[int, int]) → Dict[int, float][source]

Builds a mapping of Unique Identifiers (UIDs) to their current numeric values.

Parameters:

  • eq – The symbolic expression to analyze.

  • event_params_array – Array containing resolved event parameters.

  • x – Array containing state and algebraic variables.

  • params_array – Array containing constant model parameters.

  • dx – Array containing derivative values.

  • uid2idx_event_params – Mapping of UID to index for event parameters.

  • uid2idx_vars – Mapping of UID to index for variables.

  • uid2idx_params – Mapping of UID to index for constants.

  • uid2idx_diff – Mapping of UID to index for derivatives.

Returns:

A dictionary mapping UIDs to their float values.

VeraGridEngine.Simulations.Rms.initialization_rms.can_compute_init(var: Var, eq: Expr | Const, mdl: Block, init_guess: Dict[int, float], diff_init_guess: Dict[int, float], uid2idx_diff: Dict[int, int], uid2idx_vars: Dict[int, int]) → bool[source]

Determines if an initialization equation is computable based on current knowns.

Parameters:

  • var – Target variable.

  • eq – The expression to evaluate.

  • mdl – The model block.

  • init_guess – Current variable guesses.

  • diff_init_guess – Current derivative guesses.

  • uid2idx_diff – UID map for derivatives.

  • uid2idx_vars – UID map for variables.

Returns:

Boolean indicating if all dependencies are met.

VeraGridEngine.Simulations.Rms.initialization_rms.collect_reduced_initialization_problem(problem: Any, allow_state_equilibrium: bool) → Tuple[List[Var], List[Var], List[Var], List[Expr], ndarray] | None[source]

Collect the reduced initialization unknowns and residual equations without compiling them.

Parameters:

  • problem (EmtProblemTemplate) – EMT problem being initialized.

  • allow_state_equilibrium (bool) – Whether unresolved states may use f(x,z,p)=0.

Returns:

Tuple (unknown_vars, residual_eqs, state_unknown_mask) or None.

Return type:

Tuple[List[Var], List[Expr], np.ndarray] | None

VeraGridEngine.Simulations.Rms.initialization_rms.evaluate_initialization_jacobian(reduced_system: ReducedInitializationSystem, problem: Any, x: ndarray, dx: ndarray, runtime_params: ndarray, constant_params: ndarray) → csc_matrix[source]

Evaluate the reduced initialization Jacobian.

Parameters:

  • reduced_system – Reduced initialization system.

  • problem – EMT problem being initialized.

  • x – Full EMT variable vector.

  • dx – Full EMT differential vector.

  • runtime_params – Runtime-parameter vector.

  • constant_params – Constant-parameter vector.

Returns:

Reduced sparse Jacobian.

VeraGridEngine.Simulations.Rms.initialization_rms.evaluate_initialization_residual(reduced_system: ReducedInitializationSystem, problem: Any, x: ndarray, dx: ndarray, runtime_params: ndarray, constant_params: ndarray) → ndarray[source]

Evaluate the reduced initialization residual.

Parameters:

  • reduced_system – Reduced initialization system.

  • problem – EMT problem being initialized.

  • x – Full EMT variable vector.

  • dx – Full EMT differential vector.

  • runtime_params – Runtime-parameter vector.

  • constant_params – Constant-parameter vector.

Returns:

Reduced residual vector.

VeraGridEngine.Simulations.Rms.initialization_rms.event_param_is_resolved(v: Var, mdl: Block) → bool[source]

Checks if an event parameter has been assigned a concrete value.

Parameters:

  • v – The variable representing the event parameter.

  • mdl – The symbolic model block.

Returns:

True if resolved, False otherwise.

VeraGridEngine.Simulations.Rms.initialization_rms.extract_unknown_events_vector(problem: Any, unknown_events: List[Var], event_x: ndarray) → ndarray[source]

Extract the reduced unknown vector from the full EMT variable vector.

Parameters:

  • problem – Rms problem being initialized.

  • unknown_vars – Unknown variables solved by the reduced system.

  • x – Full EMT variable vector.

Returns:

Reduced unknown vector.

VeraGridEngine.Simulations.Rms.initialization_rms.extract_unknown_vector(problem: Any, unknown_vars: List[Var], x: ndarray) → ndarray[source]

Extract the reduced unknown vector from the full EMT variable vector.

Parameters:

  • problem – Rms problem being initialized.

  • unknown_vars – Unknown variables solved by the reduced system.

  • x – Full EMT variable vector.

Returns:

Reduced unknown vector.

VeraGridEngine.Simulations.Rms.initialization_rms.init_explicit_emt(mdl: Block, sys_vars: Dict[int, Var], sys_diff_vars: Dict[int, Var], variable_parameters: List[Var], event_parameters_eqs: List[Expr | Const], constant_parameters: List[Var], init_guess: Dict[int, float], diff_init_guess: Dict[int, float], uid2idx_vars: Dict[int, int], uid2idx_diff: Dict[int, int], uid2idx_params: Dict[int, int], uid2idx_event_params: Dict[int, int], compiler_names_dict: Dict[int, str], alias_names_dict: Dict[int, str], VARIABLE_PARAMS_NAME: str, VARS_NAME: str, DIFF_NAME: str, CONSTANT_PARAMS_NAME: str, verbose: bool = False) → Tuple[Dict[int, float], Dict[int, float]] | None[source]

Initializes the EMT model by solving initialization and differential equations.

This function performs a topological-like resolution of model variables. It uses fixed-point iteration for self-referencing equations and handles dependencies between algebraic and differential states.

Parameters:

  • mdl – Symbolic model block.

  • sys_vars – Registry of system variables.

  • sys_diff_vars – Registry of system differential variables.

  • variable_parameters – List of parameters that change on events.

  • event_parameters_eqs – Initial equations for event parameters.

  • constant_parameters – List of constant parameters.

  • init_guess – Initial guesses for variables.

  • diff_init_guess – Initial guesses for derivatives.

  • uid2idx_vars – Index map for variables.

  • uid2idx_diff – Index map for derivatives.

  • uid2idx_params – Index map for parameters.

  • uid2idx_event_params – Index map for event parameters.

  • compiler_names_dict – Map for variable naming in compilation.

  • alias_names_dict – Map for variable aliases.

  • VARIABLE_PARAMS_NAME – Name for variable parameter array.

  • VARS_NAME – Name for state variable array.

  • DIFF_NAME – Name for derivative array.

  • CONSTANT_PARAMS_NAME – Name for constant parameter array.

  • verbose – Whether to print explicit initialization diagnostics.

Returns:

Updated initial guesses and modified model block.

VeraGridEngine.Simulations.Rms.initialization_rms.init_pseudo_transient(problem: EmtProblemTemplate, options: EmtOptions) → EmtInitializationReport[source]

Run the EMT-native initialization workflow forcing the pseudo-transient path.

Parameters:

  • problem – EMT problem being initialized.

  • options – EMT simulation options.

Returns:

Initialization report.

VeraGridEngine.Simulations.Rms.initialization_rms.load_persistent_initialization_solution(cache_key: str) → Dict[str, object] | None[source]

Load one persistent reduced initialization result.

Parameters:

cache_key (str) – Deterministic cache key.

Returns:

Cached payload or None.

Return type:

Dict[str, object] | None

VeraGridEngine.Simulations.Rms.initialization_rms.run_emt_explicit_initialization(problem: EmtProblemTemplate, verbose: bool = False) → None[source]

Run the explicit EMT initialization stage on a full problem object.

Parameters:

  • problem – EMT problem being initialized.

  • verbose – Print explicit initialization details.

Returns:

None

VeraGridEngine.Simulations.Rms.initialization_rms.run_reduced_newton_initialization(reduced_system: ReducedInitializationSystem, problem: Any, event_x: ndarray, x: ndarray, dx: ndarray, constant_params: ndarray) → bool[source]

Solve the reduced initialization system with damped sparse Newton iterations.

Parameters:

  • reduced_system – Reduced initialization system.

  • problem – EMT problem being initialized.

  • x – Full EMT variable vector updated in place.

  • event_x – Full Rms variable vector updated in place.

  • dx – Full EMT differential vector.

  • runtime_params – Runtime-parameter vector.

  • constant_params – Constant-parameter vector.

  • options – EMT simulation options.

  • report – Initialization report updated in place.

Returns:

True if Newton converged.

VeraGridEngine.Simulations.Rms.initialization_rms.run_reduced_pseudo_transient_initialization(reduced_system: ReducedInitializationSystem, problem: EmtProblemTemplate, x: ndarray, event_x: ndarray, dx: ndarray, constant_params: ndarray) → bool[source]

Solve the reduced initialization system with a pseudo-transient fallback.

Parameters:

  • reduced_system – Reduced initialization system.

  • problem – EMT problem being initialized.

  • x – Full EMT variable vector updated in place.

  • dx – Full EMT differential vector.

  • event_x – Runtime-parameter vector.

  • constant_params – Constant-parameter vector.

Returns:

True if pseudo-transient converged.

VeraGridEngine.Simulations.Rms.initialization_rms.run_rms_native_initialization(problem: Any, options: RmsOptions)[source]

Run the EMT-native initialization stages after PF projection and explicit init.

The workflow keeps the current PF/explicit seeds intact, then solves only the unresolved subset with a reduced consistent Newton method. When Newton fails, the workflow may fall back to a pseudo-transient continuation. Missing differential initial values are computed automatically from the state equations.

Parameters:

  • problem – EMT problem being initialized.

  • options – EMT simulation options.

Returns:

Initialization report.

VeraGridEngine.Simulations.Rms.initialization_rms.scatter_unknown_event_vector(problem: Any, unknown_events: List[Var], event_x: ndarray, reduced_event_x: ndarray) → None[source]

Scatter the reduced unknown vector back into the full Rms variable vector.

Parameters:

  • problem – EMT problem being initialized.

  • unknown_vars – Unknown variables solved by the reduced system.

  • x – Full EMT variable vector updated in place.

  • reduced_x – Reduced unknown vector.

Returns:

None

VeraGridEngine.Simulations.Rms.initialization_rms.scatter_unknown_vector(problem: Any, unknown_vars: List[Var], x: ndarray, reduced_x: ndarray) → None[source]

Scatter the reduced unknown vector back into the full Rms variable vector.

Parameters:

  • problem – EMT problem being initialized.

  • unknown_vars – Unknown variables solved by the reduced system.

  • x – Full EMT variable vector updated in place.

  • reduced_x – Reduced unknown vector.

Returns:

None

VeraGridEngine.Simulations.Rms.initialization_rms.solve_reduced_linear_system(matrix: csc_matrix, rhs: ndarray, dense_threshold: int) → ndarray[source]

Solve one reduced linear system using a dense or sparse backend depending on size.

Parameters:

  • matrix – Reduced Jacobian-like matrix.

  • rhs – Right-hand-side vector.

  • dense_threshold – Dense/sparse switching threshold.

Returns:

Linear-system solution vector.

VeraGridEngine.Simulations.Rms.rms_driver module

class VeraGridEngine.Simulations.Rms.rms_driver.RmsSimulationDriver(grid: MultiCircuit, options: RmsOptions, pf_results: PowerFlowResults, engine: EngineType = VeraGrid)[source]

Bases: DriverTemplate

name = 'Rms Simulation'
options
pf_results: PowerFlowResults
problem: RmsProblemDae | None
run()[source]

Main function to initialize and run the system simulation.

This function sets up logging, starts the dynamic simulation, and logs the outcome. It handles and logs any exceptions raised during execution. :return:

run_time_simulation()[source]

Performs the numerical integration using the chosen method. :return:

tpe = 'RMS Dynamic'

Dynamic wrapper to use with Qt

VeraGridEngine.Simulations.Rms.rms_options module

class VeraGridEngine.Simulations.Rms.rms_options.RmsOptions(time_step: float = 0.001, simulation_time: float = 5, tolerance: float = 1e-06, integration_method: DynamicIntegrationMethod = DAE_BackEuler, initialization_method: RmsInitializationMethod = Explicit, problem_type: RmsProblemTypes = RmsProblemDae, vars_to_save: List[Var] | None = None, use_init_values: bool = False, max_iter: int = 1000, verbose: int = 0)[source]

Bases: OptionsTemplate

Rms simulation options

CLASS_NON_EDITABLE_PROPERTIES: Tuple[str, ...] = ('idtag', 'diff_changes')
CLASS_PROPERTIES_WITH_PROFILE: Dict[str, str] = {}
CLASS_PROPERTY_DECLARATIONS: Tuple[GCProp, ...] = (prop:idtag, prop:name, prop:code, prop:rdfid, prop:action, prop:comment, prop:diff_changes, prop:integration_method, prop:initialization_method, prop:problem_type, prop:time_step, prop:simulation_time, prop:tolerance, prop:use_init_values, prop:max_iter, prop:rms_event_groups)
CLASS_PROPERTY_LIST: Tuple[GCProp, ...] = (prop:idtag, prop:name, prop:code, prop:rdfid, prop:action, prop:comment, prop:diff_changes, prop:integration_method, prop:initialization_method, prop:problem_type, prop:time_step, prop:simulation_time, prop:tolerance, prop:use_init_values, prop:max_iter, prop:rms_event_groups)
CLASS_REGISTERED_PROPERTIES: Dict[str, GCProp] = {'action': prop:action, 'code': prop:code, 'comment': prop:comment, 'diff_changes': prop:diff_changes, 'idtag': prop:idtag, 'initialization_method': prop:initialization_method, 'integration_method': prop:integration_method, 'max_iter': prop:max_iter, 'name': prop:name, 'problem_type': prop:problem_type, 'rdfid': prop:rdfid, 'rms_event_groups': prop:rms_event_groups, 'simulation_time': prop:simulation_time, 'time_step': prop:time_step, 'tolerance': prop:tolerance, 'use_init_values': prop:use_init_values}
LOCAL_PROPERTY_DECLARATIONS: Tuple[GCProp, ...] = (prop:integration_method, prop:initialization_method, prop:problem_type, prop:time_step, prop:simulation_time, prop:tolerance, prop:use_init_values, prop:max_iter, prop:rms_event_groups)
action: ActionType
comment: str
device_type: DeviceType
diff_changes
selected_to_merge

VeraGridEngine.Simulations.Rms.rms_problem_factory module

VeraGridEngine.Simulations.Rms.rms_problem_factory.build_rms_problem(grid: Any, options: RmsOptions, pf_results: Any, progress_signal: Any) → Any[source]

VeraGridEngine.Simulations.Rms.rms_results module

class VeraGridEngine.Simulations.Rms.rms_results.RmsResults(time_array: DatetimeIndex, rms_events_group_names: ndarray[tuple[Any, ...], dtype[str_]], rms_events_group_idtags: ndarray[tuple[Any, ...], dtype[str_]], variables: List[Var], uid2idx: Dict[int, int], vars_glob_name2uid: Dict[str, int], devices_vars_info: Dict[Generator | Battery | Load | ExternalGrid | StaticGenerator | Shunt | ControllableShunt | CurrentInjection | Line | DcLine | Transformer2W | HvdcLine | VSC | UPFC | Winding | Switch | SeriesReactance | FluidNode | FluidPath | FluidP2x | FluidTurbine | FluidPump | Substation | Bus | BusBar | VoltageLevel | Country | Region | Community | Municipality | Area | Zone | Transformer3W | TransformerNW | OverheadLineType | Wire | TransformerType | EmissionGas | BranchGroup | LineLocations | LineLocation | ModellingAuthority | Facility | Fuel | Investment | InvestmentsGroup | Contingency | ContingencyGroup | RemedialAction | RemedialActionGroup | Technology | Owner | UndergroundLineType | SequenceLineType | RmsModelTemplate | EmtModelTemplate | FmuTemplate | RmsEvent | RmsEventsGroup | ShortCircuitEvent | IfMeasurement | ItMeasurement | QfMeasurement | PfMeasurement | QtMeasurement | PtMeasurement | QiMeasurement | PiMeasurement | VmMeasurement | VaMeasurement | PgMeasurement | QgMeasurement, List[Var]], parameter_value_maps: List[Dict[str, float]] | None = None, has_event_group_results: ndarray[tuple[Any, ...], dtype[str_]] | None = None)[source]

Bases: ResultsTemplate

CLASS_DATA_VARIABLES = {'converged': <VeraGridEngine.Simulations.results_template.ResultsProperty object>, 'dynamic_metadata_json': <VeraGridEngine.Simulations.results_template.ResultsProperty object>, 'has_event_group_results': <VeraGridEngine.Simulations.results_template.ResultsProperty object>, 'rms_events_group_idtags': <VeraGridEngine.Simulations.results_template.ResultsProperty object>, 'rms_events_group_names': <VeraGridEngine.Simulations.results_template.ResultsProperty object>, 'time_array': <VeraGridEngine.Simulations.results_template.ResultsProperty object>, 'values': <VeraGridEngine.Simulations.results_template.ResultsProperty object>, 'well_initialized': <VeraGridEngine.Simulations.results_template.ResultsProperty object>}
CLASS_RESULTS_DECLARATIONS = (<VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>)
LOCAL_RESULTS_DECLARATIONS = (<VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>, <VeraGridEngine.Simulations.results_template.ResultsProperty object>)
consolidate_after_loading() → None[source]

Refresh the dynamic dimensions after disk restore.

Returns:

None.

converged
devices_vars_info: Dict[ALL_DEV_TYPES, List[Var]]
dynamic_metadata_json
get_devices_dict_tree() → Dict[DeviceType, Dict[Generator | Battery | Load | ExternalGrid | StaticGenerator | Shunt | ControllableShunt | CurrentInjection | Line | DcLine | Transformer2W | HvdcLine | VSC | UPFC | Winding | Switch | SeriesReactance | FluidNode | FluidPath | FluidP2x | FluidTurbine | FluidPump | Substation | Bus | BusBar | VoltageLevel | Country | Region | Community | Municipality | Area | Zone | Transformer3W | TransformerNW | OverheadLineType | Wire | TransformerType | EmissionGas | BranchGroup | LineLocations | LineLocation | ModellingAuthority | Facility | Fuel | Investment | InvestmentsGroup | Contingency | ContingencyGroup | RemedialAction | RemedialActionGroup | Technology | Owner | UndergroundLineType | SequenceLineType | RmsModelTemplate | EmtModelTemplate | FmuTemplate | RmsEvent | RmsEventsGroup | ShortCircuitEvent | IfMeasurement | ItMeasurement | QfMeasurement | PfMeasurement | QtMeasurement | PtMeasurement | QiMeasurement | PiMeasurement | VmMeasurement | VaMeasurement | PgMeasurement | QgMeasurement, List[Var]]][source]
Returns:

get_parameter_value(group_idx: int, device_idtag: str, parameter_name: str) → float | None[source]

Get one exported parameter value for one event group.

Parameters:

  • group_idx – Event-group index.

  • device_idtag – Stable device identifier.

  • parameter_name – Canonical symbolic parameter name.

Returns:

Parameter scalar value, or None.

get_var(uid: int) → Var[source]
Parameters:

uid

Returns:

get_vars_data(var_list: List[Var], group_idx: int = 0) → ndarray[tuple[Any, ...], dtype[float64]] | ndarray[tuple[int, int], dtype[float64]][source]

Get time, vars data matrix for the vars selection :param var_list: List of vars :param group_idx: group index :return: data (time, vars)

has_event_group_results
ng
nt
nv
parameter_value_maps: List[Dict[str, float]]
plot_var(var: Var, group_idx: int = 0)[source]
Parameters:

  • var

  • group_idx

Returns:

prepare_for_saving() → None[source]

Refresh the serialized dynamic metadata before the result archive is written.

Returns:

None.

restore_dynamic_metadata(grid) → None[source]

Restore dynamic variable metadata from the serialized payload.

Parameters:

grid – Current circuit used to resolve device idtags.

Returns:

None.

rms_events_group_idtags
rms_events_group_names
uid2idx: Dict[int, int]
uid2vars_glob_name
values
variable_array
variables
vars_glob_name2uid
well_initialized

VeraGridEngine.Simulations.Rms.rms_worker module

Module contents