NonstationaryProcessesBase

A dictionary containing brief descriptions of each Process field:.

• process: A Function with a method for Process types that performs a particular simulation. See NonstationaryProcesses.jl for examples.
• parameter_profile: A tuple of Functions that describe how each parameter of a system evolves over time. These can be functions, or curried functions of parameters given in :parameter_profile_parameters. See e.g. constantParameter, Discontinuous
• parameter_profile_parameters: A tuple of parameters (which may also be tuples) for each :parameter_profile
• X0: The initial conditions, given as a vector equal in length to number of variables in the system
• t0: The initial time of the simulation, at which the system has the state :X0
• transient_t0: The length of time to simulate the system, from the initial conditions :X0 at :t0, that is discarded when retrieving the timeseries
• dt: The time step of the simulation and solver
• savedt: The sampling period of the solution's timeseries, which must be a multiple of :dt
• tmax: The final time point of the simulation. The duration of the simulation is then :tmax - :transient_t0, and the duration of the returned time series is :tmax - :t0. See times
• alg: The algorithm used to solve DifferentialEquations.jl processes. See, for example, a list of ODE solvers
• solver_opts: A dictionary of additional options passed to the :alg. This can include solver tolerances, adaptive timesteps, or the maximum number of iterations. See the common solver options
• solver_rng: An integer seed for the random number generator, set to a random number by default
• id: A unique integer ID for a given Process
• date: The date at which the Process was created
• solution: The solution of the simulation in its native format (e.g. an ODE solution)
• varnames: Dummy names for the variables of a Process, defaulting to [:x, :y, :z, ...]

Field aliases for Process constructors, given as a dictionary of (field=>alias) pairs.

 Discontinuous

A type that contains a discontinuous function and an index of any of its discontinuities. This allows the construction of step parameter profiles that retain discontinuity information. You can also call the Discontinuous` type like a normal function, if you want to.

Process(; process=nothing, process_kwargs...)

Define a Process that simulates a given system, specified by process::Function, and any simulation parameters (including control parameters, sampling parameters, solver parameters, and some metadata like the date and a simulation ID). For a complete list of process_kwargs, see the fieldguide. A Process can also be used to create other Processes using the syntax S = (P::Process)(;process_kwargs...), which will first copy P then update any fields given in process_kwargs

Return the indices of parameter profiles that are not constant

Return the profiles of a Process as a vector-outputting function with the form f(t::Real) -> ::Vector

Return the profiles of a Process as a vector of scalar-valued functions each with the form f(t::Real) -> ::Real

parameterseries(P::Process; p=nothing, times_kwargs...)

Return the profiles of a Process as parameter values at time indices given by times. p specified the indices of the parameters to return (e.g. 1 or [2, 3]). If p is a vector, the values will be returned in an nₚ×nₜ matrix.

Save the solution of a Process in a given folder. This replaces the :solution field of the Process with the location of the saved data, and subsequent calls of timeseries read from this file.

Copy then solve a Process

Solve a Process by calling the (::Process).process method.

Return the :solution of a Process as a formatted time series. cf. timeseries

Remove a transient from a Process by dropping any time-series values between :transient_t0 and :t0, as well as setting the intitial condition to the value of the solution at :t0.

tuplef2ftuple(f::Tuple{Function}, params::Tuple)

Convert a vector of curried functions f that each accept an element of the parameter tuple params into a function of the form f(t) -> x::Vector, where xᵢ = fᵢ(paramsᵢ)(t) for i = 1:length(f)

updateparam(P::Process, p::Integer, profile::Function)
updateparam(P, p, value::Union{Number, Tuple, Vector})
updateparam(P, p, profile, value)

Copy a Process with a new set of :parameter_profiles and :parameter_profile_parameters. p is an integer specifying which parameter to update, profile is the new profile, and value contains the new :parameter_profile_parameters.

Retrieve the solution of a Process as a ToolsArray, starting from :t0, at a sampling period of :save_dt. This function will solve the Process and populate the :solution only if the Process has not yet been simulated.

times(P::Process; transient::Bool=false)

Return the time indices of a Process, optionally including the transient.