DickeModel.ClassicalSystems

abstract struct ClassicalSystem

This abstract object represents a classical system that may be passed to multiple functions in this module. To generate a system, use ClassicalDicke.ClassicalDickeSystem or use ClassicalLMG.ClassicalLMGSystem.

function integrate(system::ClassicalSystem,
                   u₀::AbstractVector{<:Real},
                   t::Real;
                   t₀=0.0::Real,
                   tol=1e-12::Real,
                   get_fundamental_matrix::Bool=false,
                   integrator_alg=TsitPap8(),
                   use_big_numbers::Bool=false,
                   integate_backwards::Bool=false,
                   fundamental_matrix_initial=nothing,
                   kargs...)

This function integrates initial condition u₀ from t₀ to t under the Hamiltonian system determined by system, returning an instance of OrdinaryDiffEq.ODESolution.

Arguments

• system is an instance of ClassicalSystems.ClassicalSystem.
• u₀ is an array which codifies the initial condition [Q,q,P,p] for ClassicalDicke and [Q,P] for ClassicalLMG.
• t is the start time of the integration.

Keyword arguments

• t₀ is the start of the integration (defaults to t₀ = 0.0) ClassicalSystems.ClassicalSystem.
• tol is the tolerance for the integration, which determines both abstol and reltol in OrdinaryDiffEq.solve
• get_fundamental_matrix determines whether to also compute the fundametal matrix of the system. If true, the result at each time is an ArrayPartition(x,Φ), so that x=result.x[2] retrieves the coordinate and Ψ=result.x[2] retrieves the fundamental matrix. Default is false. Note that the integration is consideribly slowed down if this parameter is set to true.
• integrator_alg is the integration algorithm to use. Defaults to TsitPap8 (Tsitouras-Papakostas 8/7 Runge-Kutta method). See the DifferentialEquations documentation for other options.
• use_big_numbers forces the integration to be performed with BigFloat instead of Float, allowing for infinite numerical precision, but hindering speed substantially. Defaults to false.
• integate_backwards tells the integrator to integrate back in time, from -t₀ to -t. Defaults to false.
• fundamental_matrix_initial is the initial value if get_fundamental_matrix is true. The default value is the identity matrix.
• Additional kargs are passed to OrdinaryDiffEq.solve.

function lyapunov_spectrum(system::ClassicalSystem,
    x::AbstractVector{<:Real},
    t::Real = 100;
    λtol::Real = 1e-5, 
    λreltol::Real = 1e-3,
    maxiters::Integer = 100,
    verbose::Bool = true,
    kargs...)

Calculates the Lyapunov spectrum at point x. The algorithm used is given in Fig. 3.7 of Ref. [9], which basically integrates the fundamental matrix and renormalizes in intervals of length t, until the oscillations of the Lyapunov exponets go bellow λtol + λ*λreltol.

Arguments

• system is an instance of ClassicalSystems.ClassicalSystem.
• x is an array which codifies the initial condition [Q,q,P,p] for ClassicalDicke and [Q,P] for ClassicalLMG.
• t is the time intervals for which to integrate. This value must not be too big, or the fundamental matrix may get too large and errors will occur. Default value is 100, which is fine most of the time.

Keyword arguments

• λtol is the absolute tolerance ($E_a$ in Fig. 3.7 of Ref. [9]). Default is 1e-5.
• λreltol is the relative tolerance ($E_r$ in Fig. 3.7 of Ref. [9]). Default is 1e-3.
• maxiters is the maximum number of iterations. Default is 100.
• verbose is a boolean toggling the progress bar (default is true, which enables the progress bar).
• kargs are redirected to integrate.

function lyapunov_exponent(system::ClassicalSystem,
    x::AbstractVector{<:Real},
    t::Real = 100; kargs...)

Returns the maximal Lyapunov exponent for x by calling maximum(lyapunov_spectrum(system, x, t; kargs...)). Same arguments as lyapunov_spectrum apply.