gemseo / problems / ode

# van_der_pol module¶

The Van der Pol (VDP) problem describing an oscillator with non-linear damping.

Van der Pol, B. & Van Der Mark, J. Frequency Demultiplication. Nature 120, 363–364 (1927).

The Van der Pol problem is written as follows:

$\frac{d^2 x(t)}{dt^2} - \mu (1-x(t)^2) \frac{dx(t)}{dt} + x = 0$

where $$x(t)$$ is the position coordinate as a function of time, and $$\mu$$ is a scalar parameter indicating the stiffness.

This problem can be rewrittent in a 2-dimensional form with only first-order derivatives. Let $$y = \frac{dx}{dt}$$ and $$s = \begin{pmatrix}x\\y\end{pmatrix}$$. Then the Van der Pol problem is:

$\frac{ds}{dt} = f(s, t)$

with

$\begin{split}f : s = \begin{pmatrix} x \\ y \end{pmatrix} \mapsto \begin{pmatrix} y \\ \mu (1-x^2) y - x \end{pmatrix}\end{split}$

The jacobian of this function can be expressed analytically:

$\begin{split}\mathrm{Jac}\, f = \begin{pmatrix} 0 & 1 \\ -2\mu xy - 1 & \mu (1 - x^2) \end{pmatrix}\end{split}$

There is no exact solution to the Van der Pol oscillator problem in terms of known tabulated functions (see Panayotounakos et al. « On the Lack of Analytic Solutions of the Van Der Pol Oscillator ». ZAMM 83, nᵒ 9 (1 septembre 2003)).

class gemseo.problems.ode.van_der_pol.VanDerPol(initial_time=0, final_time=0.5, mu=1000.0, use_jacobian=True, state_vector=None)[source]

Bases: ODEProblem

Representation of an oscillator with non-linear damping.

Parameters:
• mu (float) –

The stiffness parameter.

By default it is set to 1000.0.

• initial_time (float) –

The start of the integration interval.

By default it is set to 0.

• final_time (float) –

The end of the integration interval.

By default it is set to 0.5.

• use_jacobian (bool) –

Whether to use the analytical expression of the Jacobian. If false, use finite differences to estimate the Jacobian.

By default it is set to True.

• state_vector (NDArray[float]) – The state vector of the system.

check()

Ensure the parameters of the problem are consistent.

Raises:

ValueError – If the state and time shapes are inconsistent.

Return type:

None

check_jacobian(state_vector, approximation_mode=ApproximationMode.FINITE_DIFFERENCES, step=1e-06, error_max=1e-08)

Check if the analytical jacobian is correct.

Compare the value of the analytical jacobian to a finite-element approximation of the jacobian at user-specified points.

Parameters:
• state_vector (_SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes]) – The state vector at which the jacobian is checked.

• approximation_mode (ApproximationMode) –

The approximation mode.

By default it is set to “finite_differences”.

• step (float) –

The step used to approximate the gradients.

By default it is set to 1e-06.

• error_max (float) –

The error threshold above which the jacobian is deemed to be incorrect.

By default it is set to 1e-08.

Raises:

ValueError – Either if the approximation method is unknown, if the shapes of the analytical and approximated Jacobian matrices are inconsistent or if the analytical gradients are wrong.

Returns:

Whether the jacobian is correct.

Return type:

None

func: Callable[[NDArray[float], NDArray[float]], NDArray[float]]

The right-hand side of the ODE.

initial_state: NDArray[float]

The initial conditions $$(t_0,s_0)$$ of the ODE.

integration_interval: tuple[float, float]

The interval of integration.

jac: Callable[[NDArray[float], NDArray[float]], NDArray[float]]

The Jacobian function of the right-hand side of the ODE.

result: ODEResult

The result of the ODE problem.

state_vect: NDArray[float]

State vector $$s=(x, \dot{x})$$ of the system.

time_vector: NDArray[float]

The times at which the solution should be evaluated.

## Examples using VanDerPol¶

Solve an ODE: the Van der Pol problem

Solve an ODE: the Van der Pol problem