typos

Author: isaacsas

docs/src/basics/Composition.md

@@ -254,4 +254,5 @@ causes the solver to take very small steps around the discontinuity, and
 sometimes leads to early stopping due to `dt <= dt_min`. The correct way to
 handle such dynamics is to tell the solver about the discontinuity by means of a
 root-finding equation, which can be modeling using [`ODESystem`](@ref)'s event
-support. Please see the tutorial on [Callbacks and Events](@ref events).
+support. Please see the tutorial on [Callbacks and Events](@ref events) for
+details and examples.

docs/src/basics/Events.md

@@ -25,12 +25,13 @@ functional affect](@id func_affects) representation is also allowed as described
 below.
 
 ## Continuous Events
-The basic purely symbolic continuous event interface is
+The basic purely symbolic continuous event interface to encode *one* continuous
+event is
 ```julia
 AbstractSystem(eqs, ...; continuous_events::Vector{Equation})
 AbstractSystem(eqs, ...; continuous_events::Pair{Vector{Equation}, Vector{Equation}})
 ```
-In the former equations that evaluate to 0 will represent conditions that should
+In the former, equations that evaluate to 0 will represent conditions that should
 be detected by the integrator, for example to force stepping to times of
 discontinuities. The latter allow modeling of events that have an effect on the
 state, where the first entry in the `Pair` is a vector of equations describing
@@ -135,17 +136,17 @@ hline!([0], l=(:black, 5), primary=false)
 
 ### [Generalized functional affect support](@id func_affects)
 In some instances, a more flexible response to events is needed, which cannot be
-encapsulated by a symbolic equations. For example, a component may implement
+encapsulated by symbolic equations. For example, a component may implement
 complex behavior that is inconvenient or impossible to represent symbolically.
 ModelingToolkit therefore supports regular Julia functions as affects: instead
 of one or more equations, an affect is defined as a `tuple`:
 ```julia
 [x ~ 0] => (affect!, [v, x], [p, q], ctx)
 ```
 where, `affect!` is a Julia function with the signature: `affect!(integ, u, p,
-ctx)`; `[u,v]` and `[p,q]` are the states (variables) and parameters that are
-accessed by `affect!`, respectively; and `ctx` is a context that is passed to
-`affect!` as the `ctx` argument.
+ctx)`; `[u,v]` and `[p,q]` are the symbolic states (variables) and parameters
+that are accessed by `affect!`, respectively; and `ctx` is a context that is
+passed to `affect!` as the `ctx` argument.
 
 `affect!` receives a [DifferentialEquations.jl
 integrator](https://docs.sciml.ai/stable/modules/DiffEqDocs/basics/integrator/)
@@ -173,39 +174,42 @@ parameter `q` has been renamed `p2`.
 As an example, here is the bouncing ball example from above using the functional
 affect interface:
 ```@example events
-sts = @variables y(t), v(t)
+sts = @variables x(t), v(t)
 par = @parameters g = 9.8
-bb_eqs = [D(y) ~ v
+bb_eqs = [D(x) ~ v
           D(v) ~ -g]
 
 function bb_affect!(integ, u, p, ctx)
     integ.u[u.v] = -integ.u[u.v]
 end
 
+reflect = [x ~ 0] => (bb_affect!, [v], [], nothing)
+
 @named bb_model = ODESystem(bb_eqs, t, sts, par,
-                            continuous_events = [[y ~ 0] => (bb_affect!, [v], [], nothing)])
+                            continuous_events = reflect)
 
 bb_sys = structural_simplify(bb_model)
-u0 = [v => 0.0, y => 50.0]
+u0 = [v => 0.0, x => 1.0]
 
-bb_prob = ODEProblem(bb_sys, u0, (0, 15.0))
+bb_prob = ODEProblem(bb_sys, u0, (0, 5.0))
 bb_sol = solve(bb_prob, Tsit5())
 
 plot(bb_sol)
 ```
 
 ## Discrete events support
 In addition to continuous events, discrete events are also supported. The
-general interface to represent one discrete event is
+general interface to represent a collection of discrete events is
 ```julia
-AbstractSystem(eqs, ...; discrete_events::[condition1 => affect1, condition2 => affect2])
+AbstractSystem(eqs, ...; discrete_events = [condition1 => affect1, condition2 => affect2])
 ```
-where conditions are symbolic expressions that should evaluate to `true` when
-the affect should be executed. Here `affect1` and `affect2` are each either a
-vector of one or more symbolic equations, or a functional affect, just as for
-continuous events. As before for any *one* event the symbolic affect equations
-can either all change states (i.e. variables) or all change parameters, but one
-can not currently mix state and parameter changes within one individual event.
+where conditions are symbolic expressions that should evaluate to `true` when an
+individual affect should be executed. Here `affect1` and `affect2` are each
+either a vector of one or more symbolic equations, or a functional affect, just
+as for continuous events. As before for any *one* event the symbolic affect
+equations can either all change states (i.e. variables) or all change
+parameters, but one can not currently mix state and parameter changes within one
+individual event.
 
 ### Example: Injecting cells into a population
 Suppose we have a population of `N(t)` cells that can grow and die, and at time
@@ -234,8 +238,9 @@ the integrator stops at that time. In the next section we show how one can
 bypass this needed by using a preset-time callback.
 
 Note that more general logical expressions can be built, for example, suppose we
-want the event to occur at that time only if the solution is smaller than 50% of its
-steady-state value(which is 100), we can encode this by modifying the event to
+want the event to occur at that time only if the solution is smaller than 50% of
+its steady-state value (which is 100). We can encode this by modifying the event
+to
 ```@example events
 injection = ((t == tinject) & (N < 50)) => [N ~ N + M]
 
@@ -244,14 +249,15 @@ oprob = ODEProblem(osys, u0, tspan, p)
 sol = solve(oprob, Tsit5(); tstops = 10.0)
 plot(sol)
 ```
-Since the solution is not smaller than half its steady-state value at the event
-time, the event condition now returns false.
+Since the solution is *not* smaller than half its steady-state value at the
+event time, the event condition now returns false.
 
 Let's now also add a drug at time `tkill` that turns off production of new
 cells, modeled by setting `α = 0.0`
 ```@example events
 @parameters tkill
 
+# we reset the first event to just occur at tinject
 injection = (t == tinject) => [N ~ N + M]
 
 # at time tkill we turn off production of cells
@@ -273,12 +279,11 @@ events.
 A preset-time event is triggered at specific set times, which can be
 passed in a vector like
 ```julia
-discrete_events=[[1.0, 4.0] => [v ~ -v]]
+discrete_events = [[1.0, 4.0] => [v ~ -v]]
 ```
 This will change the sign of `v` *only* at `t = 1.0` and `t = 4.0`.
 
-For example, our last example with treatment and killing could instead be
-modeled by
+As such, our last example with treatment and killing could instead be modeled by
 ```@example events
 injection = [10.0] => [N ~ N + M]
 killing = [20.0] => [α ~ 0.0]
@@ -301,9 +306,8 @@ discrete_events=[1.0 => [v ~ -v]]
 ```
 will change the sign of `v` at `t = 1.0`, `2.0`, ...
 
-
 Finally, we note that to specify an event at precisely one time, say 2.0 below,
 one must still use a vector
 ```julia
-discrete_events=[[2.0] => [v ~ -v]]
+discrete_events = [[2.0] => [v ~ -v]]
 ```