pockit.radau

Submodule for Legendre-Gauss-Radau pseudospectral methods.

The Radau phase is suitable for problems with continuous or discontinuous state and control variables.

class Phase(pockit.base.phasebase.PhaseBase):

Base class for one phase of an optimal control problem.

Phase( identifier: int, state: int | list[str], control: int | list[str], symbol_static_parameter: list[sympy.core.symbol.Symbol], simplify: bool = False, fastmath: bool = False)

Initialize a phase with given state, control, and static variables.

States and controls can be given as the number of variables or the list of variable names. If names are given, they are used as the names of the variables. Otherwise, the names are generated automatically as \( x_0, x_1, \dots, x_{n - 1} \).

Static variables should be identical to those defined in the system level.

The identifier should be unique for each phase in a given system to avoid possible name conflict.

It is recommended to use the System.new_phase() method of the System object to create phases instead of manually using this method.

If simplify is True, every symbolic expression will be simplified (by sympy.simplify()) before being compiled. This will slow down the speed of compilation.

If fastmath is True, the fastmath flag will be passed to the Numba JIT compiler, see Numba and LLVM documentation for details.

Arguments:

state: Number of state variables or list of state variable names.
control: Number of control variables or list of control variable names.
symbol_static_parameter: list of static parameters, should be identical to those in the System object.
identifier: Unique identifier of the phase.
simplify: Whether to use SymPy to simplify sympy.Expr objects before compilation.
fastmath: Whether to use Numba fastmath mode.

Inherited Members

pockit.base.phasebase.PhaseBase: set_dynamics; set_integral; set_phase_constraint; set_boundary_condition; set_discretization; check_continuous; check_discontinuous; check; refine_continuous; refine_discontinuous; refine; n_x; x; n_u; u; n; n_s; s; t; F_d; n_d; F_I; n_I; I; F_c; n_c; v_lb; v_ub; c_lb; c_ub; s_b; bc_0; bc_f; F_b; n_b; t_0; t_f; N; ok; index_state; index_control; index_mstage; l_v; r_v; t_m; l_m; r_m; L_m; w_m; f_v2m; T_v; T_v_coo; I_m; I_m_coo; l_d; r_d; t_m_aug; l_m_aug; r_m_aug; L_m_aug; w_aug; P; V_xu_aug; T_x_aug; I_m_aug; t_x; t_u; l_x; r_x; l_u; r_u; L_x; L_xu; L

class System(pockit.base.systembase.SystemBase):

Base class for a complete optimal control problem.

System( static_parameter: int | list[str], simplify: bool = False, fastmath: bool = False)

Initialize a system with given static parameters.

If static_parameter is an integer, the names are generated automatically as \( s_0, s_1, \dots, s_{n-1} \).

If simplify is True, every symbolic expression will be simplified (by sympy.simplify()) before being compiled. This will slow down the speed of compilation.

If fastmath is True, the fastmath flag will be passed to the Numba JIT compiler, see Numba and LLVM documentation for details.

Arguments:

static_parameter: Number of static parameters or list of static parameter names.
simplify: Whether to use SymPy to simplify sympy.Expr objects before compilation.
fastmath: Whether to use Numba fastmath mode.

Inherited Members

pockit.base.systembase.SystemBase: new_phase; set_phase; set_objective; set_system_constraint; update; objective; constraints; gradient; jacobianstructure; jacobian; hessianstructure_o; hessian_o; hessianstructure_c; hessian_c; hessianstructure; hessian; check_continuous; check_discontinuous; check; refine_continuous; refine_discontinuous; refine; n_s; s; n_p; p; F_o; n_c; F_c; v_lb; v_ub; c_lb; c_ub; N; L; ok

class Variable(pockit.base.variablebase.VariableBase):

Optimization variable for a discretized phase.

A Variable exposes its data both as a flat array for solvers and through convenient accessors for individual state and control variables. It also provides interpolation matrices for plotting and mesh adaptation.

Users normally create instances with constant_guess or linear_guess and then adjust the initial guess as needed.

Variable( phase: Phase, data: numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]])

Arguments:

phase: The Phase object to create the Variable for.
data: The underlying data array.

Inherited Members

pockit.base.variablebase.VariableBase: V_x; V_u; D_x; D_u; x; u; t_0; t_f; data; t_x; t_u; adapt

constant_guess = functools.partial(<function constant_guess_base>, <class 'Variable'>)

linear_guess = functools.partial(<function linear_guess_base>, <class 'Variable'>)