add JumpSystem docs

Author: isaacsas

docs/make.jl

@@ -15,6 +15,7 @@ makedocs(
             "systems/AbstractSystem.md",
             "systems/ODESystem.md",
             "systems/SDESystem.md",
+            "systems/JumpSystem.md",
             "systems/NonlinearSystem.md",
             "systems/OptimizationSystem.md",
             "systems/ReactionSystem.md",

docs/src/systems/JumpSystem.md

@@ -0,0 +1,21 @@
+# JumpSystem
+
+## System Constructors
+
+```@docs
+JumpSystem
+```
+
+## Composition and Accessor Functions
+
+- `sys.eqs` or `equations(sys)`: The equations that define the jump system.
+- `sys.states` or `states(sys)`: The set of states in the jump system.
+- `sys.parameters` or `parameters(sys)`: The parameters of the jump system.
+- `sys.iv` or `independent_variable(sys)`: The independent variable of the jump system.
+
+## Problem Constructors
+
+```@docs
+DiscreteProblem
+JumpProblem
+```

src/systems/jumps/jumpsystem.jl

@@ -3,39 +3,43 @@ JumpType = Union{VariableRateJump, ConstantRateJump, MassActionJump}
 """
 $(TYPEDEF)
 
-A system of jumps processes.
+A system of jump processes.
 
 # Fields
 $(FIELDS)
 
 # Example
 
 ```
-using ModelingToolKit, DiffEqJump
+using ModelingToolkit
 
 @parameters β γ t
 @variables S I R
 rate₁   = β*S*I
 affect₁ = [S ~ S - 1, I ~ I + 1]
-rate₂   = γ*I+t
+rate₂   = γ*I
 affect₂ = [I ~ I - 1, R ~ R + 1]
 j₁      = ConstantRateJump(rate₁,affect₁)
-j₂      = VariableRateJump(rate₂,affect₂)
+j₂      = ConstantRateJump(rate₂,affect₂)
 j₃      = MassActionJump(2*β+γ, [R => 1], [S => 1, R => -1])
 js      = JumpSystem([j₁,j₂,j₃], t, [S,I,R], [β,γ])
-u₀map = [S => 999, I => 1, R => 0]
-parammap = [β => .1/1000, γ => .01]
-dprob = DiscreteProblem(js2, u₀map, tspan, parammap)
-jprob = JumpProblem(js2, dprob, Direct(), save_
-
 ```
 """
 struct JumpSystem{U <: ArrayPartition} <: AbstractSystem
+    """
+    The jumps of the system. Allowable types are `ConstantRateJump`, 
+    `VariableRateJump`, `MassActionJump`.
+    """
     eqs::U
+    """The independent variable, usually time."""
     iv::Variable
+    """The dependent variables, representing the state of the system."""
     states::Vector{Variable}
+    """The parameters of the system."""
     ps::Vector{Variable}
+    """The name of the system."""
     name::Symbol
+    """The internal systems."""
     systems::Vector{JumpSystem}
 end
 
@@ -123,7 +127,16 @@ function DiffEqBase.DiscreteProblem(sys::AbstractSystem, u0map, tspan,
                                     parammap=DiffEqBase.NullParameters; kwargs...)
 ```
 
-Generates a DiscreteProblem from an AbstractSystem
+Generates a DiscreteProblem from an AbstractSystem.
+
+Continuing the example from the [`JumpSystem`](@ref) definition:
+```julia
+using DiffEqBase, DiffEqJump
+u₀map = [S => 999, I => 1, R => 0]
+parammap = [β => .1/1000, γ => .01]
+tspan = (0.0, 250.0)
+dprob = DiscreteProblem(js, u₀map, tspan, parammap)
+```
 """
 function DiffEqBase.DiscreteProblem(sys::AbstractSystem, u0map, tspan::Tuple,
                                     parammap=DiffEqBase.NullParameters(); kwargs...)
@@ -141,6 +154,12 @@ function DiffEqBase.JumpProblem(js::JumpSystem, prob, aggregator; kwargs...)
 ```
 
 Generates a JumpProblem from a JumpSystem.
+
+Continuing the example from the [`DiscreteProblem`](@ref) definition:
+```julia
+jprob = JumpProblem(js, dprob, Direct())
+sol = solve(jprob, SSAStepper())
+```
 """
 function DiffEqJump.JumpProblem(js::JumpSystem, prob, aggregator; kwargs...)