pydae.core.model_class

The Model class orchestrates the interaction between Python and the compiled C solver. It handles memory allocation, data loading, and provides the API for steady-state initialization and time-domain simulation.

Sparse backend support

The compiled shared library may use one of four linear-algebra backends:

• dense – built-in LU with partial pivoting (default)

• klu – SuiteSparse KLU (0-based CSC)

• pardiso – Intel MKL PARDISO (1-based CSR)

• accelerate – Apple Accelerate Sparse Solvers (0-based CSC, macOS)

The backend that was selected at build time is recorded in the JSON metadata file under the key "sparse_backend" (null for dense). At runtime the Model class reads this value to allocate the correct Jacobian buffer size: NNZ entries for any sparse backend, or N_xy * N_xy for the dense fallback.

Functions

test_build_pendulum(model_name[, target, sparse])

Classes

Model(model_name[, matrices_folder, data_folder])

class pydae.core.model_class.Model(model_name, matrices_folder='./build', data_folder='.')

Bases: object

A_eval()

Compute the reduced linearized state matrix A.

Eliminates the algebraic variables from the DAE linearization via the Schur complement:

A = F_x - F_y @ inv(G_y) @ G_x

Requires that jac_run_eval has been called (or calls it lazily) so that F_x, F_y, G_x, G_y are available.

Returns:

The (N_x, N_x) state matrix of the linearized system dx/dt = A @ dx around the current operating point.

Return type:

numpy.ndarray

dict2xy0(xy_0_dict)

Maps a dictionary of initial guesses to the flat xy_0 array.

get_value(name)

Gets a single scalar value from the current system state.

get_values(name)

Gets a time-series array of a variable from the stored simulation history.

ini(params_dict, xy_0='None')

Solves the steady-state (Newton-Raphson).

ini2run()

Transforms initialization states into runtime states.

jac_run_eval()

Evaluate the run Jacobian jac_run = [[F_x, F_y], [G_x, G_y]].

Calls the compiled jac_trap_eval at the current operating point to obtain jac_trap:

jac_trap = [[I - alpha*Dt*F_x,  -alpha*Dt*F_y],
            [       G_x,               G_y    ]]

then recovers the run-Jacobian blocks:

F_x = (I - jac_trap[:N_x, :N_x]) / (alpha*Dt)
F_y = -jac_trap[:N_x, N_x:]      / (alpha*Dt)
G_x =  jac_trap[N_x:, :N_x]
G_y =  jac_trap[N_x:, N_x:]

load_params(data_input)

load_xy_0(file_name='xy_0.json')

post()

Truncates pre-allocated arrays and reshapes results.

report_params(fmt='5.2f')

report_u(fmt='5.2f')

report_x(fmt='5.2f')

report_y(fmt='5.2f')

report_z(fmt='5.2f')

run(t_end, inputs_dict)

Simulates the time-domain evolution.

save_inputs_ini(file_name='inputs_ini.json')

save_params(file_name='parameters.json')

save_xy_0(file_name='xy_0.json')

set_value(name_, value)

Sets a parameter or input safely.

pydae.core.model_class.test_build_pendulum(model_name, target='ctypes', sparse=False)