SDESystem

System Constructors

ModelingToolkit.SDESystemType
struct SDESystem <: ModelingToolkit.AbstractODESystem

A system of stochastic differential equations.

Fields

  • eqs

    The expressions defining the drift term.

  • noiseeqs

    The expressions defining the diffusion term.

  • iv

    Independent variable.

  • states

    Dependent (state) variables. Must not contain the independent variable.

  • ps

    Parameter variables. Must not contain the independent variable.

  • var_to_name

    Array variables.

  • ctrls

    Control parameters (some subset of ps).

  • observed

    Observed states.

  • tgrad

    Time-derivative matrix. Note: this field will not be defined until calculate_tgrad is called on the system.

  • jac

    Jacobian matrix. Note: this field will not be defined until calculate_jacobian is called on the system.

  • Wfact

    Wfact matrix. Note: this field will not be defined until generate_factorized_W is called on the system.

  • Wfact_t

    Wfact_t matrix. Note: this field will not be defined until generate_factorized_W is called on the system.

  • name

    Name: the name of the system

  • systems

    Systems: the internal systems. These are required to have unique names.

  • defaults

    defaults: The default values to use when initial conditions and/or parameters are not supplied in ODEProblem.

  • connector_type

    type: type of the system

  • continuous_events

    continuous_events: A Vector{SymbolicContinuousCallback} that model events. The integrator will use root finding to guarantee that it steps at each zero crossing.

  • discrete_events

    discrete_events: A Vector{SymbolicDiscreteCallback} that models events. Symbolic analog to SciMLBase.DiscreteCallback that exectues an affect when a given condition is true at the end of an integration step.

  • metadata

    metadata: metadata for the system, to be used by downstream packages.

Example

using ModelingToolkit

@parameters σ ρ β
@variables t x(t) y(t) z(t)
D = Differential(t)

eqs = [D(x) ~ σ*(y-x),
       D(y) ~ x*(ρ-z)-y,
       D(z) ~ x*y - β*z]

noiseeqs = [0.1*x,
            0.1*y,
            0.1*z]

@named de = SDESystem(eqs,noiseeqs,t,[x,y,z],[σ,ρ,β])
source

To convert an ODESystem to an SDESystem directly:

ode = ODESystem(eqs,t,[x,y,z],[σ,ρ,β])
sde = SDESystem(ode, noiseeqs)

Composition and Accessor Functions

  • get_eqs(sys) or equations(sys): The equations that define the SDE.
  • get_states(sys) or states(sys): The set of states in the SDE.
  • get_ps(sys) or parameters(sys): The parameters of the SDE.
  • get_iv(sys): The independent variable of the SDE.

Transformations

Missing docstring.

Missing docstring for structural_simplify. Check Documenter's build log for details.

Missing docstring.

Missing docstring for alias_elimination. Check Documenter's build log for details.

Missing docstring.

Missing docstring for Girsanov_transform. Check Documenter's build log for details.

Analyses

Applicable Calculation and Generation Functions

calculate_jacobian
calculate_tgrad
calculate_factorized_W
generate_jacobian
generate_tgrad
generate_factorized_W
jacobian_sparsity

Problem Constructors

SciMLBase.SDEFunctionMethod
function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = sys.states, ps = sys.ps;
                                     version = nothing, tgrad=false, sparse = false,
                                     jac = false, Wfact = false, kwargs...) where {iip}

Create an SDEFunction from the SDESystem. The arguments dvs and ps are used to set the order of the dependent variable and parameter vectors, respectively.

source
SciMLBase.SDEProblemMethod
function DiffEqBase.SDEProblem{iip}(sys::SDESystem,u0map,tspan,p=parammap;
                                    version = nothing, tgrad=false,
                                    jac = false, Wfact = false,
                                    checkbounds = false, sparse = false,
                                    sparsenoise = sparse,
                                    skipzeros = true, fillzeros = true,
                                    linenumbers = true, parallel=nothing,
                                    kwargs...)

Generates an SDEProblem from an SDESystem and allows for automatically symbolically calculating numerical enhancements.

source

Expression Constructors

ModelingToolkit.SDEFunctionExprType
function DiffEqBase.SDEFunctionExpr{iip}(sys::AbstractODESystem, dvs = states(sys),
                                     ps = parameters(sys);
                                     version = nothing, tgrad=false,
                                     jac = false, Wfact = false,
                                     skipzeros = true, fillzeros = true,
                                     sparse = false,
                                     kwargs...) where {iip}

Create a Julia expression for an SDEFunction from the SDESystem. The arguments dvs and ps are used to set the order of the dependent variable and parameter vectors, respectively.

source
ModelingToolkit.SDEProblemExprType
function DiffEqBase.SDEProblemExpr{iip}(sys::AbstractODESystem,u0map,tspan,
                                    parammap=DiffEqBase.NullParameters();
                                    version = nothing, tgrad=false,
                                    jac = false, Wfact = false,
                                    checkbounds = false, sparse = false,
                                    linenumbers = true, parallel=nothing,
                                    kwargs...) where iip

Generates a Julia expression for constructing an ODEProblem from an ODESystem and allows for automatically symbolically calculating numerical enhancements.

source