pockit.radau

Submodule for Legendre-Gauss-Radau pseudo-spectral methods.

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

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

A phase is a lower level objective of a multiple-phase 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, parallel: 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 parallel is True, the parallel flag will be passed to the Numba JIT compiler, which will generate parallel code for multicore CPUs. This will slow down the speed of compilation and sometimes the speed of execution.

If fastmath is True, the fastmath flag will be passed to the Numba JIT compiler, see Numba and LLVM documentations 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 before compilation.
parallel: Whether to use Numba parallel mode.
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):

A system is the higher level objective of a multiple-phase optimal control problem.

System( static_parameter: int | list[str], simplify: bool = False, parallel: 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 documentations for details.

Arguments:

static_parameter: Number of static parameters or list of static parameter names.
simplify: Whether to use Sympy to simplify sympy.Expr before compilation.
parallel: Whether to use Numba parallel mode.
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.

Variable objects provide two kinds of interfaces:

Plain 1D array for passing to the solver;
Methods for quickly accessing specific variables for users to set and extract corresponding values.

Besides, Variable provides methods to generate interpolation matrices for mesh adaption and plotting.

Generally, users need not create Variable objects directly. A better way is to use the func:constant_guess and func:linear_guess functions to generate a starting point and possibly adjust it manually.

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'>)