rework docs a bit to reduce runtimes

Author: TorkelE

docs/pages.jl

@@ -1,5 +1,5 @@
 pages = Any[
-    "Home" => "home.md",
+    "Home" => "index.md",
     "Introduction to Catalyst" => Any[
         "introduction_to_catalyst/catalyst_for_new_julia_users.md",
         # "introduction_to_catalyst/introduction_to_catalyst.md"
@@ -14,11 +14,11 @@ pages = Any[
         # Events.
         #"model_creation/parametric_stoichiometry.md",# Distributed parameters, rates, and initial conditions.
         # Loading and writing models to files.
-        # Model visualisation.
+        "model_creation/model_visualisation.md",
         #"model_creation/network_analysis.md",
         "model_creation/chemistry_related_functionality.md",
         "Model creation examples" => Any[
-            #"model_creation/examples/basic_CRN_library.md",
+            "model_creation/examples/basic_CRN_library.md",
             "model_creation/examples/programmatic_generative_linear_pathway.md",
             #"model_creation/examples/hodgkin_huxley_equation.md",
             #"model_creation/examples/smoluchowski_coagulation_equation.md"
@@ -29,20 +29,20 @@ pages = Any[
         # Simulation introduction.
         "model_simulation/simulation_plotting.md",
         "model_simulation/simulation_structure_interfacing.md",
-        #"model_simulation/ensemble_simulations.md",
+        "model_simulation/ensemble_simulations.md",
         # Stochastic simulation statistical analysis.
-    #    "model_simulation/ode_simulation_performance.md",
-    #    # ODE Performance considerations/advice.
-    #    # SDE Performance considerations/advice.
-    #    # Jump Performance considerations/advice.
-    #    # Finite state projection
+        "model_simulation/ode_simulation_performance.md",
+        # ODE Performance considerations/advice.
+        # SDE Performance considerations/advice.
+        # Jump Performance considerations/advice.
+        # Finite state projection
     ],
     "Steady state analysis" => Any[
-    #    "steady_state_functionality/homotopy_continuation.md",
+        "steady_state_functionality/homotopy_continuation.md",
         "steady_state_functionality/nonlinear_solve.md",
         "steady_state_functionality/steady_state_stability_computation.md",        
-    #    "steady_state_functionality/bifurcation_diagrams.md",
-    #    "steady_state_functionality/dynamical_systems.md"
+        "steady_state_functionality/bifurcation_diagrams.md",
+        "steady_state_functionality/dynamical_systems.md"
     ],
     "Inverse Problems" => Any[
         # Inverse problems introduction.

docs/src/assets/long_ploting_times/model_creation/mm_kinetics.svg

@@ -137,9 +137,9 @@ using JumpProcesses
 ```
 
 This time, we will declare a so-called [SIR model for an infectious disease](@ref basic_CRN_library_sir). Note that even if this model does not describe a set of chemical reactions, it can be modelled using the same framework. The model consists of 3 species:
-* $S$, the amount of *susceptible* individuals.
-* $I$, the amount of *infected* individuals.
-* $R$, the amount of *recovered* (or *removed*) individuals.
+* *S*, the amount of *susceptible* individuals.
+* *I*, the amount of *infected* individuals.
+* *R*, the amount of *recovered* (or *removed*) individuals.
 
 It also has 2 reaction events:
 * Infection, where a susceptible individual meets an infected individual and also becomes infected.
@@ -171,6 +171,7 @@ Previously we have bundled this information into an `ODEProblem` (denoting a det
 using JumpProcesses # hide
 dprob = DiscreteProblem(sir_model, u0, tspan, params)
 jprob = JumpProblem(sir_model, dprob, Direct())
+nothing # hide
 ```
 Again, the order in which the inputs are given to the `DiscreteProblem` and the `JumpProblem` is important. The last argument to the `JumpProblem` (`Direct()`) denotes which simulation method we wish to use. For now, we recommend that users simply use the `Direct()` option, and then consider alternative ones (see the [JumpProcesses.jl docs](https://docs.sciml.ai/JumpProcesses/stable/)) when they are more familiar with modelling in Catalyst and Julia.
 
@@ -199,7 +200,7 @@ This will:
 2. Switch your current Julia session to use the current folder's environment.
 
 !!! note
- If you check any folder which has been designated as a Julia environment, it contains a Project.toml and a Manifest.toml file. These store all information regarding the corresponding environment. For non-advanced users, it is recommended to never touch these files directly (and instead do so using various functions from the Pkg package, the important ones which are described in the next two subsections).
+    If you check any folder which has been designated as a Julia environment, it contains a Project.toml and a Manifest.toml file. These store all information regarding the corresponding environment. For non-advanced users, it is recommended to never touch these files directly (and instead do so using various functions from the Pkg package, the important ones which are described in the next two subsections).
 
 ### [Installing and importing packages in Julia](@id catalyst_for_new_julia_users_packages_installing)
 Package installation and import have been described [previously](@ref catalyst_for_new_julia_users_packages_intro). However, for the sake of this extended tutorial, let us repeat the description by demonstrating how to install the [Latexify.jl](https://github.com/korsbo/Latexify.jl) package (which enables e.g. displaying Catalyst models in Latex format). First, we import the Julia Package manager ([Pkg](https://github.com/JuliaLang/Pkg.jl)) (which is required to install Julia packages):
@@ -236,15 +237,15 @@ So, why is this required, and why cannot we simply import any package installed
 The reason why all this is important is that it is *highly recommended* to, for each project, define a separate environment. To these, only add the required packages. General-purpose environments with a large number of packages often, in the long term, produce package incompatibility issues. While these might not prevent you from installing all desired package, they often mean that you are unable to use the latest version of some packages.
 
 !!! note
- A not-infrequent cause for reported errors with Catalyst (typically the inability to replicate code in tutorials) is package incompatibilities in large environments preventing the latest version of Catalyst from being installed. Hence, whenever an issue is encountered, it is useful to run `Pkg.status()` to check whenever the latest version of Catalyst is being used.
+    A not-infrequent cause for reported errors with Catalyst (typically the inability to replicate code in tutorials) is package incompatibilities in large environments preventing the latest version of Catalyst from being installed. Hence, whenever an issue is encountered, it is useful to run `Pkg.status()` to check whenever the latest version of Catalyst is being used.
 
 Some additional useful Pkg commands are:
 - `Pk.rm("PackageName")` removes a package from the current environment.
 - `Pkg.update("PackageName")`: updates the designated package.
 - `Pkg.update()`: updates all packages.
 
 !!! note
- A useful feature of Julia's environment system is that enables the exact definition of what packages and versions were used to execute a script. This supports e.g. reproducibility in academic research. Here, by providing the corresponding Project.toml and Manifest.toml files, you can enable someone to reproduce the exact program used to perform some set of analyses.
+    A useful feature of Julia's environment system is that enables the exact definition of what packages and versions were used to execute a script. This supports e.g. reproducibility in academic research. Here, by providing the corresponding Project.toml and Manifest.toml files, you can enable someone to reproduce the exact program used to perform some set of analyses.
 
 
 ---

docs/src/assets/long_ploting_times/model_creation/sir_outbreaks.svg

@@ -47,6 +47,7 @@ Just like for [parameter fitting](@ref optimization_parameter_fitting), we creat
 using Optimization
 initial_guess = [1.0, 1.0, 1.0]
 opt_prob = OptimizationProblem(pulse_amplitude, initial_guess; lb = [1e-1, 1e-1, 1e-1], ub = [1e1, 1e1, 1e1])
+nothing # hide
 ```
 !!! note
     As described in a [previous section on Optimization.jl](@ref optimization_parameter_fitting), `OptimizationProblem`s do not support setting parameter values using maps. We must instead set `initial_guess` values using a vector. Next, in the first line of our cost function, we reshape the parameter values to the common form used across Catalyst (e.g. `[:pX => p[1], :pY => p[2], :pZ => p[2]]`, however, here we use a dictionary to easier compute the steady state initial condition). We also note that the order used in this array corresponds to the order we give each parameter's bounds in `lb` and `ub`, and the order in which their values occur in the output solution.
@@ -55,6 +56,7 @@ As [previously described](@ref optimization_parameter_fitting), Optimization.jl
 ```@example behaviour_optimization
 using OptimizationBBO
 opt_sol = solve(opt_prob, BBO_adaptive_de_rand_1_bin_radiuslimited())
+nothing # hide
 ```
 Finally, we plot a simulation using the found parameter set (stored in `opt_sol.u`):
 ```@example behaviour_optimization
@@ -78,9 +80,10 @@ Through packages such as [ForwardDiff.jl](https://github.com/JuliaDiff/ForwardDi
 ```@example behaviour_optimization
 opt_func = OptimizationFunction(pulse_amplitude, AutoForwardDiff())
 opt_prob = OptimizationProblem(opt_func, initial_guess; lb = [1e-1, 1e-1, 1e-1], ub = [1e1, 1e1, 1e1])
+nothing # hide
 ``` 
 Finally, we can find the optimum using some differentiation-based optimisation methods. Here we will use [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl)'s `BFGS` method:
-```@example behaviour_optimization
+```julia
 using OptimizationOptimJL
 opt_sol = solve(opt_prob, OptimizationOptimJL.BFGS())
 ``` 

docs/src/assets/long_ploting_times/model_simulation/incomplete_brusselator_simulation.svg

@@ -60,15 +60,15 @@ To, in a similar manner, indicate that certain initial conditions are known is a
 ### Providing non-trivial measured quantities
 Sometimes, ones may not have measurements of species, but rather some combinations of species (or possibly parameters). To account for this, `measured_quantities` accepts any algebraic expression (and not just single species). To form such expressions, species and parameters have to first be `@unpack`'ed from the model. Say that we have a model where an enzyme ($E$) is converted between an active and inactive form, which in turns activates the production of a product, $P$:
 ```@example si1
-enzyme_activation = @reaction_network begin
+rs = @reaction_network begin
     (kA,kD), Eᵢ <--> Eₐ
     (Eₐ, d), 0 <-->P
 end
 ```
 If we can measure the total amount of $E$ ($=Eᵢ+Eₐ$), as well as the amount of $P$, we can use the following to assess identifiability:
-```@example si2
-@unpack Eᵢ, Eₐ = enzyme_activation
-assess_identifiability(enzyme_activation; measured_quantities = [Eᵢ + Eₐ, :P], loglevel = Logging.Error)
+```@example si1
+@unpack Eᵢ, Eₐ = rs
+assess_identifiability(rs; measured_quantities = [Eᵢ + Eₐ, :P], loglevel = Logging.Error)
 nothing # hide
 ```
 

docs/src/home.md renamed to docs/src/index.md

@@ -12,7 +12,8 @@ We will first show how to create compound species through [programmatic model co
 ```@example chem1
 using Catalyst
 t = default_t()
-@species C(t) O(t) 
+@species C(t) O(t)
+nothing # hide
 ```
 Next, we create the `CO2` compound species:
 ```@example chem1
@@ -84,14 +85,17 @@ as the components `C`, `H`, and `O` are not declared as species anywhere. Please
 Just like for normal species, it is possible to designate metadata and default values for compounds. Metadata is provided after the compound name, but separated from it by a `,`:
 ```@example chem1
 @compound (CO2, [unit="mol"]) ~ C + 2O
+nothing # hide
 ```
 Default values are designated using `=`, and provided directly after the compound name.:
 ```@example chem1
 @compound (CO2 = 2.0) ~ C + 2O
+nothing # hide
 ```
 If both default values and meta data are provided, the metadata is provided after the default value:
 ```@example chem1
 @compound (CO2 = 2.0, [unit="mol"]) ~ C + 2O
+nothing # hide
 ```
 In all of these cases, the left-hand side must be enclosed within `()`.