`EarthSciMLBase.Advection`

— TypeApply advection to a model.

`EarthSciMLBase.ConnectorSystem`

— TypeA connector for two systems.

`eqs`

`from`

`to`

`EarthSciMLBase.CoupledSystem`

— TypeA system for composing together other systems using the `couple`

function.

`systems`

: Model components to be composed together`domaininfo`

: Initial and boundary conditions and other domain information`pdefunctions`

: A vector of functions where each function takes as an argument the resulting PDESystem after DomainInfo is added to this system, and returns a transformed PDESystem.

`ops`

: A vector of operators to run during simulations.

`callbacks`

: A vector of callbacks to run during simulations.`init_callbacks`

: Objects`x`

with an`init_callback(x, Simulator)::DECallback`

method.

Things that can be added to a `CoupledSystem`

: * `ModelingToolkit.ODESystem`

s. If the ODESystem has a field in the metadata called `:coupletype`

(e.g. `ModelingToolkit.get_metadata(sys)[:coupletype]`

returns a struct type with a single field called `sys`

) then that type will be used to check for methods of `EarthSciMLBase.couple`

that use that type. * `Operator`

s * `DomainInfo`

s * Callbacks * Types `X`

that implement a `EarthSciMLBase.get_callback(::X, ::Simulator)::DECallback`

method * Other `CoupledSystem`

s * Types `X`

that implement a `EarthSciMLBase.couple(::X, ::CoupledSystem)`

or `EarthSciMLBase.couple(::CoupledSystem, ::X)`

method. * `Tuple`

s or `AbstractVector`

s of any of the things above.

`EarthSciMLBase.DomainInfo`

— TypeDomain information for a ModelingToolkit.jl PDESystem. It can be used with the `+`

operator to add initial and boundary conditions and coordinate transforms to a ModelingToolkit.jl ODESystem or Catalyst.jl ReactionSystem.

**NOTE**: The independent variable (usually time) must be first in the list of initial and boundary conditions.

`partial_derivative_funcs`

: Function that returns spatial derivatives of the partially-independent variables, optionally performing a coordinate transformation first.Current function options in this package are:

`partialderivatives_δxyδlonlat`

: Returns partial derivatives after transforming any variables named`lat`

and`lon`

from degrees to cartesian meters, assuming a spherical Earth.

Other packages may implement additional functions. They are encouraged to use function names starting with

`partialderivatives_`

.

`icbc`

: The sets of initial and/or boundary conditions.

`EarthSciMLBase.ICBCcomponent`

— TypeInitial and boundary condition components that can be combined to create an DomainInfo object.

`EarthSciMLBase.Operator`

— TypeOperators are objects that modify the current state of a `Simulator`

system. Each operator should be define a function with the signature:

``EarthSciMLBase.get_scimlop(op::Operator, s::Simulator)::AbstractSciMLOperator``

which should return a SciMLOperators.AbstractSciMLOperator. Refer to the SciMLOperators.jl documentation for more information on how to define operators.

`EarthSciMLBase.Simulator`

— TypeSpecify a simulator for large-scale model runs. `Δs`

represent the grid cell spacing in each dimension; for example `Δs = [0.1, 0.1, 1]`

would represent a grid with 0.1 spacing in the first two dimensions and 1 in the third, in whatever units the grid is natively in. The grid spacings should be given in the same order as the partial independent variables are in the provided `DomainInfo`

.

`sys::CoupledSystem`

: The system to be integrated`sys_mtk::ModelingToolkit.ODESystem`

: The ModelingToolkit version of the system`domaininfo::DomainInfo`

: Information about the spatiotemporal simulation domain`p::Vector`

: The system parameter values`u_init::Vector`

: The initial values of the system state variables`pvidx::Vector{Int64}`

: The indexes of the partial independent variables in the system parameter value vector`grid::Any`

: The discretized values of the partial independent variables`Δs::Tuple{T, T, T} where T`

: The spacings for each grid dimension`obs_fs::Any`

: Functions to get the current values of the observed variables with input arguments of time and the partial independent variables`obs_fs_idx::Dict{Symbolics.Num, Int64}`

: Indexes for the obs_fs functions`tf_fs::Any`

: Functions to get the current values of the coordinate transforms with input arguments of time and the partial independent variables

`EarthSciMLBase.SimulatorIMEX`

— TypeA simulator strategy based on implicit-explicit (IMEX) time integration. See here for additional information.

`alg`

is the ODE solver algorithm to use, which should be chosen from the Split ODE Solver algorithms listed here. In most cases, it is recommended to use a Jacobian-free Newton-Krylov linear solution method as described here.

This strategy does not currently work. Do not use. See here for more details.

`alg`

`EarthSciMLBase.SimulatorStrang`

— TypeA simulator strategy based on Strang splitting. Choose either `SimulatorStrangThreads`

or `SimulatorStrangSerial`

to run the simulation.

`SimulatorStrang`

strategies will still work if no operator is included, but any callbacks included in the system are executed together with the operators, so if there are no operators in the system, the callbacks will not be executed.

`EarthSciMLBase.SimulatorStrangSerial`

— Type```
# Specify the stiff and nonstiff ODE solver algorithm.
# `timestep` is the length of time for each splitting step.
SimulatorStrangSerial(stiffalg, nonstiffalg, timestep)
```

Perform a simulation using Strang splitting, where the MTK system is assumed to be stiff and the operators are assumed to be non-stiff. The solution will be calculated in serial.

`stiffalg`

: Stiff solver algorithm to use (see https://docs.sciml.ai/DiffEqDocs/stable/solvers/ode_solve/)`nonstiffalg`

: Non-stiff solver algorithm to use (see https://docs.sciml.ai/DiffEqDocs/stable/solvers/ode_solve/)`timestep`

: Length of each splitting time step

`EarthSciMLBase.SimulatorStrangThreads`

— Type```
# Specify the number of threads and the stiff and nonstiff ODE solver algorithm.
# `timestep` is the length of time for each splitting step.
SimulatorStrangThreads(threads, stiffalg, nonstiffalg, timestep)
# Use the default number of threads.
SimulatorStrangThreads(stiffalg, nonstiffalg, timestep)
```

Perform a simulation using Strang splitting, where the MTK system is assumed to be stiff and the operators are assumed to be non-stiff. The solution of the stiff ODE system is parallelized across grid cells using the specified number of threads.

`threads`

: Number of threads to use`stiffalg`

: Stiff solver algorithm to use (see https://docs.sciml.ai/DiffEqDocs/stable/solvers/ode_solve/)`nonstiffalg`

: Non-stiff solver algorithm to use (see https://docs.sciml.ai/DiffEqDocs/stable/solvers/ode_solve/)`timestep`

: Length of each splitting time step

`EarthSciMLBase.SimulatorStrategy`

— TypeSimulatorStrategy is an abstract type that defines the strategy for running a simulation. Each SimulatorStrategy should implement a method of:

`run!(st::SimulatorStrategy, s::Simulator{T}, u0) where T`

where u0 is the initial conditions for the system state.

`EarthSciMLBase.constBC`

— TypeConstruct constant boundary conditions equal to the value specified by `val`

.

`val`

: The value of the constant boundary conditions.`partialdomains`

: The partial domains, e.g.`[x ∈ Interval(x_min, x_max), y ∈ Interval(y_min, y_max)]`

.

`EarthSciMLBase.constIC`

— TypeConstruct constant initial conditions equal to the value specified by `val`

.

`val`

: The value of the constant initial conditions.`indepdomain`

: The independent domain, e.g.`t ∈ Interval(t_min, t_max)`

.

`EarthSciMLBase.periodicBC`

— TypeConstruct periodic boundary conditions for the given `partialdomains`

. Periodic boundary conditions are defined as when the value at one side of the domain is set equal to the value at the other side, so that the domain "wraps around" from one side to the other.

`partialdomains`

: The partial domains, e.g.`[x ∈ Interval(x_min, x_max), y ∈ Interval(y_min, y_max)]`

.

`EarthSciMLBase.zerogradBC`

— TypeConstruct zero-gradient boundary conditions for the given `partialdomains`

.

`partialdomains`

: The partial domains, e.g.`[x ∈ Interval(x_min, x_max), y ∈ Interval(y_min, y_max)]`

.

`Base.convert`

— Method```
convert(, sys; name, kwargs...)
```

Get the ODE ModelingToolkit ODESystem representation of a `CoupledSystem`

.

`Base.convert`

— Method```
convert(, sys; name, kwargs...)
```

Get the ModelingToolkit PDESystem representation of a `CoupledSystem`

.

`EarthSciMLBase.ConstantWind`

— Method```
ConstantWind(t, vals; name)
```

Construct a constant wind velocity model component with the given wind speed(s), which should include units. For example, `ConstantWind(t, 1u"m/s", 2u"m/s")`

.

`EarthSciMLBase.MeanWind`

— Method```
MeanWind(t, domain)
```

A model component that represents the mean wind velocity, where `pvars`

is the partial dependent variables for the domain.

`EarthSciMLBase.add_dims`

— Method```
add_dims(expression, vars, dims)
add_dims(equation, vars, dims)
```

Add the given dimensions to each variable in `vars`

in the given expression or equation. Each variable in `vars`

must be unidimensional, i.e. defined like `@variables u(t)`

rather than `@variables u(..)`

.

**Example:**

```
using EarthSciMLBase, ModelingToolkit
@parameters x y k t
@variables u(t) q(t)
exp = 2u + 3k*q + 1
EarthSciMLBase.add_dims(exp, [u, q], [x, y, t])
# output
1 + 2u(x, y, t) + 3k*q(x, y, t)
```

`EarthSciMLBase.add_metadata`

— MethodAdd the units and description in the variable `from`

to the variable `to`

.

`EarthSciMLBase.add_scope`

— Method```
add_scope(sys, v, iv)
```

Add a system scope to a variable name, for example so that `x`

in system `sys1`

becomes `sys1₊x`

. `iv`

is the independent variable.

`EarthSciMLBase.couple`

— Method```
couple(systems...) -> CoupledSystem
```

Couple multiple ModelingToolkit systems together.

The systems that are arguments to this system can be of type `ModelingToolkit.AbstractSystem`

, `CoupledSystem`

, `DomainInfo`

, or any type `T`

that has a method `couple(::CoupledSystem, ::T)::CoupledSystem`

or a method `couple(::T, ::CoupledSystem)::CoupledSystem`

defined for it.

`EarthSciMLBase.couple2`

— Method```
couple2()
```

Perform bi-directional coupling for two equation systems.

To specify couplings for system pairs, create methods for this function with the signature:

`EarthSciMLBase.couple2(a::ACoupler, b::BCoupler)::ConnectorSystem`

where `ACoupler`

and `BCoupler`

are `:coupletype`

s defined like this:

```
struct ACoupler sys end
@named asys = ODESystem([], t, metadata=Dict(:coupletype=>ACoupler))
```

`EarthSciMLBase.dims`

— Method```
dims(
icbc::EarthSciMLBase.ICcomponent
) -> Vector{Symbolics.Num}
```

Returns the dimensions of the independent and partial domains associated with these initial or boundary conditions.

`EarthSciMLBase.domains`

— Method```
domains(icbc::EarthSciMLBase.ICcomponent) -> Vector
```

Returns the domains associated with these initial or boundary conditions.

`EarthSciMLBase.get_coupletype`

— MethodReturn the coupling type associated with the given system.

`EarthSciMLBase.get_dv`

— MethodReturn the dependent variable, which is the first argument of the term, unless the term is a time derivative, in which case the dependent variable is the argument of the time derivative.

`EarthSciMLBase.get_needed_vars`

— Method```
get_needed_vars(sys)
```

Return the indexes of the system variables that the state variables of the final simplified system depend on. This should be done before running `structural_simplify`

on the system.

`EarthSciMLBase.graph`

— MethodCreate a graph from a CoupledSystem using the MetaGraphsNext package.

`EarthSciMLBase.grid`

— Method```
grid(d, Δs)
```

Return the ranges representing the discretization of the partial independent variables for this domain, based on the discretization intervals given in `Δs`

`EarthSciMLBase.icbc`

— Method```
icbc(di, states)
```

Return a vector of equations that define the initial and boundary conditions for the given state variables.

`EarthSciMLBase.init_callback`

— MethodTypes that implement an:

`init_callback(x, Simulator)::DECallback`

method can also be coupled into a `CoupledSystem`

. The `init_callback`

function will be run before the simulator is run to get the callback.

`EarthSciMLBase.init_u`

— MethodInitialize the state variables.

`EarthSciMLBase.ivar`

— Method```
ivar(di::DomainInfo) -> Any
```

Return the independent variable associated with these initial and boundary conditions.

`EarthSciMLBase.mtk_op`

— MethodReturn a SciMLOperator to apply the MTK system to each column of s.u after reshaping to a matrix.

`EarthSciMLBase.observed_expression`

— Method```
observed_expression(eqs, x)
```

Return an expression for the observed value of a variable `x`

after substituting in the constants observed values of other variables. `extra_eqs`

is a list of additional equations to use in the substitution.

`EarthSciMLBase.observed_function`

— Method```
observed_function(eqs, x, coords)
```

Return a function to for the observed value of a variable `x`

based on the input arguments in `coords`

. `extra_eqs`

is a list of additional equations to use to determine the value of `x`

.

`EarthSciMLBase.ode_step!`

— MethodTake a step using the ODE solver.

`EarthSciMLBase.operator_compose`

— Function```
operator_compose(a, b)
operator_compose(a, b, translate)
```

Compose to systems of equations together by adding the right-hand side terms together of equations that have matching left-hand sides. The left hand sides of two equations will be considered matching if:

- They are both time derivatives of the same variable.
- The first one is a time derivative of a variable and the second one is the variable itself.
- There is an entry in the optional
`translate`

dictionary that maps the dependent variable in the first system to the dependent variable in the second system, e.g.`Dict(sys1.sys.x => sys2.sys.y)`

. - There is an entry in the optional
`translate`

dictionary that maps the dependent variable in the first system to the dependent variable in the second system, with a conversion factor, e.g.`Dict(sys1.sys.x => sys2.sys.y => 6)`

.

`EarthSciMLBase.param_to_var`

— MethodReplace the parameter `p`

in the system `sys`

with a new variable that has the same name, units, and description as `p`

.

```
param_to_var(sys, ps)
```

This can be useful to replace a parameter that does not change in time in a model component with one specified by another system that does change in time (or space). For example, the code below specifies a first-order loss equation, and then changes the temperature (which determines the loss rate) with a temperature value that varies in time. ```

`EarthSciMLBase.partialderivative_transforms`

— Method```
partialderivative_transforms(di::DomainInfo) -> Vector{Any}
```

Return transform factor to multiply each partial derivative operator by, for example to convert from degrees to meters.

`EarthSciMLBase.partialderivatives`

— Method```
partialderivatives(di::DomainInfo) -> Any
```

Return the partial derivative operators for the given domain.

`EarthSciMLBase.partialderivatives_δxyδlonlat`

— Method```
partialderivatives_δxyδlonlat(pvars; default_lat)
```

Return partial derivative operator transform factors corresponding for the given partial-independent variables after converting variables named `lon`

and `lat`

from degrees to x and y meters, assuming they represent longitude and latitude on a spherical Earth.

`EarthSciMLBase.prune_observed`

— Method```
prune_observed(sys)
```

Remove equations from an ODESystem where the variable in the LHS is not present in any of the equations for the state variables. This can be used to remove computationally intensive equations that are not used in the final model.

`EarthSciMLBase.pvars`

— Method```
pvars(di::DomainInfo) -> Any
```

Return the partial independent variables associated with these initial and boundary conditions.

`EarthSciMLBase.run!`

— Function```
run!(s::Simulator, st::SimulatorIMEX; ...)
run!(s::Simulator, st::SimulatorIMEX, u; kwargs...)
```

Run the simulation. `kwargs`

are passed to the ODEProblem and ODE solver constructors.

`EarthSciMLBase.run!`

— Method```
run!(st::EarthSciMLBase.SimulatorStrategy, simulator)
```

Run the simulation.

`EarthSciMLBase.run!`

— Method```
run!(
s::Simulator{T},
st::EarthSciMLBase.SimulatorStrang;
...
) -> Any
run!(
s::Simulator{T},
st::EarthSciMLBase.SimulatorStrang,
u;
kwargs...
) -> Any
```

Run the simualation. `kwargs`

are passed to the ODEProblem and ODE solver constructors.

`EarthSciMLBase.single_ode_step!`

— MethodTake a step using the ODE solver with the given IIchunk (grid cell interator) and integrator.

`EarthSciMLBase.steplength`

— Method```
steplength(timesteps)
```

Return the time step length common to all of the given `timesteps`

. Throw an error if not all timesteps are the same length.

`EarthSciMLBase.stiff_callback`

— MethodA callback to periodically run the stiff solver.

`EarthSciMLBase.threaded_ode_step!`

— MethodTake a step using the ODE solver.

`EarthSciMLBase.time_range`

— Method```
time_range(d)
```

Return the time range associated with this domain.

`EarthSciMLBase.timesteps`

— Method```
timesteps(tsteps)
```

Return the time points during which integration should be stopped to run the operators.

`EarthSciMLBase.utype`

— Method```
utype(_)
```

Return the data type of the state variables for this domain, based on the data types of the boundary conditions domain intervals.