documentation improvements #1329
Closed
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(plus markdownlint-disable)
Member
|
I tried to check the changes, but I just see lots and lots of added line breaks, and I'm not sure I really see the use of those. |
Contributor
Author
|
As my first sentence of the PR states: Feel free to cherry-pick whatever commits you like. When you don't like all the added linebreaks, ignore the commits It is true what when having a look at the result of all the commits at once, you only see the added linebreaks. But you can go through the commits one by one (excluding the above). Most of them are then quite short. The above mentioned three commits are just fixes of hints from markdownlint (VS Code). to helps to keep a consistent (documentation) style. |
Member
|
Thank you for your time and effort on making this PR! Generally formatting changes should be kept distinct from other changes (i.e. via separate PRs). This makes review feasible and enables us to more easily see what content is actually being changed. If you could open a shorter PR that removes whitespace/formatting commits so we can review the more important changes involving broken links, typos, spelling and such that would be really helpful.
Please keep in mind that maintainers of projects can be quite busy, so finding time to cherry pick your commits, open our own PRs with them, and then review them, will likely result in your work languishing an extended amount of time (as will submission of one very long PR with thousands of lines of changes vs. multiple shorter PRs that only change a few hundred lines). If you would like to help facilitate the process please open a PR yourself with formatting related-changes removed. |
Member
|
Some guidance about SciML's practices for PRs is at: https://docs.sciml.ai/ColPrac/stable/#Guidance-on-contributing-PRs |
Contributor
Author
|
As you can guess my time is also limited. Unfortunately you were a bit too vague what you expect me to do. Before submitting the PR I already reordered the commits to start with the formatting stuff (starting with And since I am not a Git expert, I could offer to go back in time in my repo and first submit a new PR with the above three "whitespace" commits. After you have accepted these I think the rest can go in one more PR. I already have prepared one more PR which is to harmonize the spelling to UK or US, see my branches Because of my only noob level of git I just made these branches from the HEAD of my master branch, thus they include also all the above commits ... So please let me know if the suggested way of providing new PRs is OK for you. |
Contributor
Author
|
Almost four weeks later still no response ... 😞 |
Member
|
Sorry, as I said in my previous reply, we appreciate and would happily take a PR without the formatting changes! I can’t tell you how to extract those commits as I am not a git expert either — I would just Google or ask an AI. I don’t think either of Torkel or I sees a pressing need for the formatting changes, or has the time to review a PR of the many formatting changes to ensure it doesn’t make a non-formatting/problematic change. If/when we are concerned with cleaning up formatting we would probably just reactivate JuliaFormatter (which is currently turned off due to bugs resulting in poor reformats). |
Member
|
yeah, as Sam says the formatting changes make it hard to see what the PR actually does. Generally I am not unhappy with the formatting, and while improvements can be made I'd rather just sit with Sam and figure that out. Also, I am not sure how useful spelling fixed across UK/US English will be. I.e. different people use different spelling, so right now it will just vary from doc page to doc page. If there are inconsistencies in a single page I guess it wouldn't hurt updating though. |
Contributor
Author
|
I would have loved to prove that I haven't messed something up, but unfortunately I already got a lot of errors when trying to make the docs of commit 587ce00 😭 So I tried to drop the "whitespace" commits in a rebase but -- as I expected -- this ended up in a lot of conflicts. But what I could do was a diff between commits 587ce00 and https://github.com/Mo-Gul/Catalyst.jl/commit/8b30e468152b1392888345ac28763ea3f3e6833b. Ignoring all whitespace and blank lines only resulted in one false positive file remaining
(Please note that in this screenshot you can see the order of commits after my rebase, but for whatever reason the shown order at GitHub is a different one. Most likely this is because on GitHub they are ordered by date.) Comparing that with the same "ignore settings" revealed only 2 (remaining) differences (see the bottom of the following screenshot, which -- as I already stated -- are false positives.
So I offer it again: I can try to revert all changes after the three "whitespace" commits and we'll go for them as a first PR. The remaining commits then can go in a second PR which should be reviewable, as you can review/verify in the following collapsible. Patch file of the remaining commits docs/old_files/unused_tutorials/models.md | 14 +++----
docs/src/api/core_api.md | 28 +++++++-------
docs/src/api/network_analysis_api.md | 2 +-
docs/src/devdocs/dev_guide.md | 2 +-
docs/src/faqs.md | 2 +-
docs/src/index.md | 24 ++++++------
.../catalyst_for_new_julia_users.md | 41 ++++++++++----------
.../introduction_to_catalyst.md | 4 +-
.../introduction_to_catalyst/math_models_intro.md | 2 +-
.../src/inverse_problems/behaviour_optimisation.md | 18 ++++-----
.../global_sensitivity_analysis.md | 4 +-
.../optimization_ode_param_fitting.md | 21 ++++++-----
.../inverse_problems/petab_ode_param_fitting.md | 7 ++--
.../inverse_problems/structural_identifiability.md | 4 +-
.../chemistry_related_functionality.md | 1 -
docs/src/model_creation/compositional_modeling.md | 2 +-
docs/src/model_creation/constraint_equations.md | 2 -
docs/src/model_creation/dsl_advanced.md | 3 +-
docs/src/model_creation/dsl_basics.md | 3 +-
.../examples/hodgkin_huxley_equation.md | 2 +-
.../examples/noise_modelling_approaches.md | 1 -
.../programmatic_generative_linear_pathway.md | 1 -
.../examples/smoluchowski_coagulation_equation.md | 6 +--
docs/src/model_creation/functional_parameters.md | 1 -
.../model_file_loading_and_export.md | 28 +++++++-------
docs/src/model_creation/model_visualisation.md | 2 +-
.../programmatic_CRN_construction.md | 2 +-
.../examples/interactive_brusselator_simulation.md | 1 -
.../finite_state_projection_simulation.md | 1 -
.../model_simulation/ode_simulation_performance.md | 9 +----
.../model_simulation/simulation_introduction.md | 44 +++++++++++-----------
docs/src/network_analysis/crn_theory.md | 5 +--
docs/src/network_analysis/odes.md | 2 +-
.../spatial_modelling/lattice_reaction_systems.md | 1 -
.../lattice_simulation_structure_ interaction.md | 3 +-
.../bifurcation_diagrams.md | 1 -
.../dynamical_systems.md | 7 +---
.../examples/bifurcationkit_codim2.md | 1 -
.../examples/bifurcationkit_periodic_orbits.md | 1 -
.../homotopy_continuation.md | 7 +---
.../steady_state_functionality/nonlinear_solve.md | 6 +--
docs/src/v14_migration_guide.md | 2 +-
test/upstream/mtk_problem_inputs.jl | 2 +-
43 files changed, 143 insertions(+), 177 deletions(-)
diff --git a/docs/old_files/unused_tutorials/models.md b/docs/old_files/unused_tutorials/models.md
index 1b862869..01e48d58 100644
--- a/docs/old_files/unused_tutorials/models.md
+++ b/docs/old_files/unused_tutorials/models.md
@@ -109,19 +109,19 @@ plot(sol, lw=2)
Each `Reaction` within `reactions(rn)` has a number of subfields. For `rx` a
`Reaction` we have:
-* `rx.substrates`, a vector of ModelingToolkit expressions storing each
+- `rx.substrates`, a vector of ModelingToolkit expressions storing each
substrate variable.
-* `rx.products`, a vector of ModelingToolkit expressions storing each product
+- `rx.products`, a vector of ModelingToolkit expressions storing each product
variable.
-* `rx.substoich`, a vector storing the corresponding stoichiometry of each
+- `rx.substoich`, a vector storing the corresponding stoichiometry of each
substrate species in `rx.substrates`.
-* `rx.prodstoich`, a vector storing the corresponding stoichiometry of each
+- `rx.prodstoich`, a vector storing the corresponding stoichiometry of each
product species in `rx.products`.
-* `rx.rate`, a `Number`, `ModelingToolkit.Sym`, or ModelingToolkit expression
+- `rx.rate`, a `Number`, `ModelingToolkit.Sym`, or ModelingToolkit expression
representing the reaction rate. E.g., for a reaction like `k*X, Y --> X+Y`,
we'd have `rate = k*X`.
-* `rx.netstoich`, a vector of pairs mapping the ModelingToolkit expression for
+- `rx.netstoich`, a vector of pairs mapping the ModelingToolkit expression for
each species that changes numbers by the reaction to how much it changes. E.g.,
for `k, X + 2Y --> X + W`, we'd have `rx.netstoich = [Y(t) => -2, W(t) => 1]`.
-* `rx.only_use_rate`, a boolean that is `true` if the reaction was made with
+- `rx.only_use_rate`, a boolean that is `true` if the reaction was made with
non-filled arrows and should ignore mass action kinetics. `false` by default.
diff --git a/docs/src/api/core_api.md b/docs/src/api/core_api.md
index 792ceb6e..34f0ccb3 100644
--- a/docs/src/api/core_api.md
+++ b/docs/src/api/core_api.md
@@ -100,7 +100,7 @@ of all options currently available.
- [`ivs`](@ref dsl_advanced_options_ivs): Allows the designation of a set of symbols as system independent variables.
- [`compounds`](@ref chemistry_functionality_compounds): Allows the designation of compound species.
- [`observables`](@ref dsl_advanced_options_observables): Allows the designation of compound observables.
-- [`default_noise_scaling`](@ref simulation_intro_SDEs_noise_saling): Enables the setting of a default noise scaling expression.
+- [`default_noise_scaling`](@ref simulation_intro_SDEs_noise_scaling): Enables the setting of a default noise scaling expression.
- [`differentials`](@ref constraint_equations_coupling_constraints): Allows the designation of differentials.
- [`equations`](@ref constraint_equations_coupling_constraints): Allows the creation of algebraic and/or differential equations.
- [`continuous_events`](@ref constraint_equations_events): Allows the creation of continuous events.
@@ -124,22 +124,22 @@ retrieve info from just a base [`ReactionSystem`](@ref) `rn`, ignoring
sub-systems of `rn`, one can use the ModelingToolkit accessors (these provide
direct access to the corresponding internal fields of the `ReactionSystem`)
-* `ModelingToolkit.get_unknowns(rn)` is a vector that collects all the species
+- `ModelingToolkit.get_unknowns(rn)` is a vector that collects all the species
defined within `rn`, ordered by species and then non-species variables.
-* `Catalyst.get_species(rn)` is a vector of all the species variables in the system. The
+- `Catalyst.get_species(rn)` is a vector of all the species variables in the system. The
entries in `get_species(rn)` correspond to the first `length(get_species(rn))`
components in `get_unknowns(rn)`.
-* `ModelingToolkit.get_ps(rn)` is a vector that collects all the parameters
+- `ModelingToolkit.get_ps(rn)` is a vector that collects all the parameters
defined *within* reactions in `rn`.
-* `ModelingToolkit.get_eqs(rn)` is a vector that collects all the
+- `ModelingToolkit.get_eqs(rn)` is a vector that collects all the
[`Reaction`](@ref)s and `Symbolics.Equation` defined within `rn`, ordering all
`Reaction`s before `Equation`s.
-* `Catalyst.get_rxs(rn)` is a vector of all the [`Reaction`](@ref)s in `rn`, and
+- `Catalyst.get_rxs(rn)` is a vector of all the [`Reaction`](@ref)s in `rn`, and
corresponds to the first `length(get_rxs(rn))` entries in `get_eqs(rn)`.
-* `ModelingToolkit.get_iv(rn)` is the independent variable used in the system
+- `ModelingToolkit.get_iv(rn)` is the independent variable used in the system
(usually `t` to represent time).
-* `ModelingToolkit.get_systems(rn)` is a vector of all sub-systems of `rn`.
-* `ModelingToolkit.get_defaults(rn)` is a dictionary of all the default values
+- `ModelingToolkit.get_systems(rn)` is a vector of all sub-systems of `rn`.
+- `ModelingToolkit.get_defaults(rn)` is a dictionary of all the default values
for parameters and species in `rn`.
The preceding accessors do not allocate, directly accessing internal fields of
@@ -149,20 +149,20 @@ To retrieve information from the full reaction network represented by a system
`rn`, which corresponds to information within both `rn` and all sub-systems, one
can call:
-* `ModelingToolkit.unknowns(rn)` returns all species *and variables* across the
+- `ModelingToolkit.unknowns(rn)` returns all species *and variables* across the
system, *all sub-systems*, and all constraint systems. Species are ordered
before non-species variables in `unknowns(rn)`, with the first `numspecies(rn)`
entries in `unknowns(rn)` being the same as `species(rn)`.
-* [`species(rn)`](@ref) is a vector collecting all the chemical species within
+- [`species(rn)`](@ref) is a vector collecting all the chemical species within
the system and any sub-systems that are also `ReactionSystems`.
-* `ModelingToolkit.parameters(rn)` returns all parameters across the
+- `ModelingToolkit.parameters(rn)` returns all parameters across the
system, *all sub-systems*, and all constraint systems.
-* `ModelingToolkit.equations(rn)` returns all [`Reaction`](@ref)s and all
+- `ModelingToolkit.equations(rn)` returns all [`Reaction`](@ref)s and all
`Symbolics.Equations` defined across the system, *all sub-systems*, and all
constraint systems. `Reaction`s are ordered ahead of `Equation`s with the
first `numreactions(rn)` entries in `equations(rn)` being the same as
`reactions(rn)`.
-* [`reactions(rn)`](@ref) is a vector of all the `Reaction`s within the system
+- [`reactions(rn)`](@ref) is a vector of all the `Reaction`s within the system
and any sub-systems that are also `ReactionSystem`s.
These accessors will generally allocate new arrays to store their output unless
diff --git a/docs/src/api/network_analysis_api.md b/docs/src/api/network_analysis_api.md
index 4894fa06..84ea584a 100644
--- a/docs/src/api/network_analysis_api.md
+++ b/docs/src/api/network_analysis_api.md
@@ -6,7 +6,7 @@ CurrentModule = Catalyst
Note, currently API functions for network analysis and conservation law analysis
do not work with constant species (which are generated by SBML, and can be [declared
-in Catalyst as well](@ref dsl_advanced_options_constant_species).
+in Catalyst as well](@ref dsl_advanced_options_constant_species)).
For more information about these functions, please see the sections of the docs on
[network ODE representation](@ref network_analysis_odes) and [chemical reaction network theory](@ref network_analysis_structural_aspects).
diff --git a/docs/src/devdocs/dev_guide.md b/docs/src/devdocs/dev_guide.md
index 131f14f6..7da574e2 100644
--- a/docs/src/devdocs/dev_guide.md
+++ b/docs/src/devdocs/dev_guide.md
@@ -15,7 +15,7 @@ continuing stability of releases. Before making a release one should
3. [Check docs build](@ref devdocs_advice_doc_inspection) with the capped dependencies.
Visually verify via checking the artifact in the doc build that the docs actually
look ok (since sometimes issues can arise that do not lead to actual errors in the doc CI).
-5. Release via the [registration
+4. Release via the [registration
issue](https://github.com/SciML/Catalyst.jl/issues/127) with the
command: `@JuliaRegistrator register branch=release-15.0.0`, modifying as appropriate
for the version you are releasing.
diff --git a/docs/src/faqs.md b/docs/src/faqs.md
index d0082ab0..0caef2d7 100644
--- a/docs/src/faqs.md
+++ b/docs/src/faqs.md
@@ -136,7 +136,7 @@ simulations](@ref introduction_to_catalyst_ratelaws) section. Leaving this keywo
point stoichiometry will give an error message.
For a more extensive documentation of using non-integer stoichiometric
-coefficients, please see the [Symbolic Stochiometries](@ref
+coefficients, please see the [Symbolic Stoichiometries](@ref
parametric_stoichiometry) section.
## How to set default values for initial conditions and parameters?
diff --git a/docs/src/index.md b/docs/src/index.md
index f29d49f3..936c2854 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -259,19 +259,19 @@ support it, please star the repository as such metrics may help us secure fundin
you use Catalyst as part of your research, teaching, or other activities, we would be grateful if you
could cite our work:
-```
+```bibtex
@article{CatalystPLOSCompBio2023,
- doi = {10.1371/journal.pcbi.1011530},
- author = {Loman, Torkel E. AND Ma, Yingbo AND Ilin, Vasily AND Gowda, Shashi AND Korsbo, Niklas AND Yewale, Nikhil AND Rackauckas, Chris AND Isaacson, Samuel A.},
- journal = {PLOS Computational Biology},
- publisher = {Public Library of Science},
- title = {Catalyst: Fast and flexible modeling of reaction networks},
- year = {2023},
- month = {10},
- volume = {19},
- url = {https://doi.org/10.1371/journal.pcbi.1011530},
- pages = {1-19},
- number = {10},
+ doi = {10.1371/journal.pcbi.1011530},
+ author = {Loman, Torkel E. AND Ma, Yingbo AND Ilin, Vasily AND Gowda, Shashi AND Korsbo, Niklas AND Yewale, Nikhil AND Rackauckas, Chris AND Isaacson, Samuel A.},
+ journal = {PLOS Computational Biology},
+ publisher = {Public Library of Science},
+ title = {Catalyst: Fast and flexible modeling of reaction networks},
+ year = {2023},
+ month = {10},
+ volume = {19},
+ url = {https://doi.org/10.1371/journal.pcbi.1011530},
+ pages = {1-19},
+ number = {10},
}
```
diff --git a/docs/src/introduction_to_catalyst/catalyst_for_new_julia_users.md b/docs/src/introduction_to_catalyst/catalyst_for_new_julia_users.md
index f2467ec7..a8166547 100644
--- a/docs/src/introduction_to_catalyst/catalyst_for_new_julia_users.md
+++ b/docs/src/introduction_to_catalyst/catalyst_for_new_julia_users.md
@@ -57,9 +57,9 @@ rand(100, 100)^3.5
nothing # hide
```
-(This code creates a random 100x100 matrix, and takes it to the power of 3.5)
+(This code creates a random 100x100 matrix, and takes it to the power of 3.5.)
-This is useful to know when you e.g. declare, simulate, or plot, a Catalyst model. The first time you run a command there might be a slight delay. However, subsequent runs will be much quicker. This holds even if you make minor adjustments before the second run (such as changing simulation initial conditions).
+This is useful to know when you e.g. declare, simulate, or plot a Catalyst model. The first time you run a command there might be a slight delay. However, subsequent runs will be much quicker. This holds even if you make minor adjustments before the second run (such as changing simulation initial conditions).
## [Installing and activating packages](@id catalyst_for_new_julia_users_packages_intro)
@@ -72,7 +72,7 @@ using Pkg
Pkg.add("Catalyst")
```
-Here, the Julia package manager package (`Pkg`) is by default installed on your computer when Julia is installed, and can be activated directly. Next, we install an ODE solver from a sub-library of the larger `OrdinaryDiffEq` package, and install the `Plots` package for making graphs. We will import the recommended default solver from the `OrdinaryDiffEqDefault` sub-library. A full list of `OrdinaryDiffEq` solver sublibraries can be found on the sidebar of [this page](https://docs.sciml.ai/OrdinaryDiffEq/stable/).
+Here, the Julia package manager package (`Pkg`) is by default installed on your computer when Julia is installed, and can be activated directly. Next, we install an ODE solver from a sub-library of the larger `OrdinaryDiffEq` package, and install the `Plots` package for making graphs. We will import the recommended default solver from the `OrdinaryDiffEqDefault` sub-library. A full list of `OrdinaryDiffEq` solver sub-libraries can be found on the sidebar of [this page](https://docs.sciml.ai/OrdinaryDiffEq/stable/).
```julia
Pkg.add("OrdinaryDiffEqDefault")
@@ -108,21 +108,21 @@ rn = @reaction_network begin
end
```
-For more information on how to use the Catalyst model creator (also known as *the Catalyst DSL*), please read [the corresponding documentation](https://docs.sciml.ai/Catalyst/stable/catalyst_functionality/dsl_description/).
+For more information on how to use the Catalyst model creator (also known as *the Catalyst DSL*), please read [the corresponding documentation](https://docs.sciml.ai/Catalyst/stable/model_creation/dsl_basics/).
-Next, we wish to simulate our model. To do this, we need to provide some additional information to the simulator. This is
+Next, we wish to simulate our model. To do this, we need to provide some additional information to the simulator. This is:
-* The initial condition. That is, the concentration (or copy numbers) of each species at the start of the simulation.
-* The time span. That is, the time frame over which we wish to run the simulation.
-* The parameter values. That is, the values of the model's parameters for this simulation.
+- The initial condition. That is, the concentration (or copy numbers) of each species at the start of the simulation.
+- The time span. That is, the time frame over which we wish to run the simulation.
+- The parameter values. That is, the values of the model's parameters for this simulation.
-The initial condition is given as a *Vector*. This is a type which collects several different values. To declare a vector, the values are specific within brackets, `[]`, and separated by `,`. Since we only have one species, the vector holds a single element. In this element, we set the value of $X$ using the `:X => 1.0` syntax. Here, we first denote the name of the species (with a `:` pre-appended, which creates a `Symbol`), next follows a `=>` and then the value of $X$. Since we wish to simulate the *concentration* of X over time, we will let the initial condition be decimal valued.
+The initial condition is given as a *Vector*. This is a type which collects several different values. To declare a vector, the values are specified within brackets, `[]`, and separated by `,`. Since we only have one species, the vector holds a single element. In this element, we set the value of $X$ using the `:X => 1.0` syntax. Here, we first denote the name of the species (with a `:` pre-appended, which creates a `Symbol`), next follows a `=>` and then the value of $X$. Since we wish to simulate the *concentration* of $X$ over time, we will let the initial condition be decimal valued.
```@example ex2
u0 = [:X => 1.0]
```
-The timespan sets the time point at which we start the simulation (typically `0.0` is used) and the final time point of the simulation. These are combined into a two-valued *tuple*. Tuples are similar to vectors, but are enclosed by `()` and not `[]`. Again, we will let both time points be decimal valued.
+The time span sets the time point at which we start the simulation (typically `0.0` is used) and the final time point of the simulation. These are combined into a two-valued *tuple*. Tuples are similar to vectors, but are enclosed by `()` and not `[]`. Again, we will let both time points be decimal valued.
```@example ex2
tspan = (0.0, 10.0)
@@ -134,9 +134,9 @@ Finally, the parameter values are, like the initial conditions, given in a vecto
params = [:b => 1.0, :d => 0.2]
```
-Please read here for more information on [vectors](https://docs.julialang.org/en/v1/manual/arrays/) and [tuples](https://docs.julialang.org/en/v1/manual/types/#Tuple-Types).
+Please read the corresponding manual entries on [vectors](https://docs.julialang.org/en/v1/manual/arrays/) and [tuples](https://docs.julialang.org/en/v1/manual/types/#Tuple-Types) for more information.
-Next, before we can simulate our model, we bundle all the required information together in a so-called `ODEProblem`. Note that the order in which the input (the model, the initial condition, the timespan, and the parameter values) is provided to the `ODEProblem` matters. E.g. the parameter values cannot be provided as the first argument, but have to be the fourth argument. Here, we save our `ODEProblem` in the `oprob` variable.
+Next, before we can simulate our model, we bundle all the required information together in a so-called `ODEProblem`. Note that the order in which the input (the model, the initial condition, the time span, and the parameter values) is provided to the `ODEProblem` matters. E.g. the parameter values cannot be provided as the first argument, but have to be the fourth argument. Here, we save our `ODEProblem` in the `oprob` variable.
```@example ex2
oprob = ODEProblem(rn, u0, tspan, params)
@@ -162,7 +162,7 @@ For more information about the numerical simulation package, please see the [Dif
To make this introduction more comprehensive, we here provide another example, using a more complicated model. Instead of simulating our model as concentrations evolve over time, we will now simulate the individual reaction events through the [Gillespie algorithm](https://en.wikipedia.org/wiki/Gillespie_algorithm) (a common approach for adding *noise* to models).
-Remember (unless we have restarted Julia) we do not need to activate our packages (through the `using` command) again. However, we do need to install, and then import, the JumpProcesses package (just to perform Gillespie, and other jump, simulations)
+Remember (unless we have restarted Julia) we do not need to activate our packages (through the `using` command) again. However, we do need to install, and then import, the [`JumpProcesses`](https://docs.sciml.ai/JumpProcesses/stable/) package (just to perform Gillespie, and other jump, simulations).
```julia
Pkg.add("JumpProcesses")
@@ -171,19 +171,19 @@ 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.
-* Recovery, where an infected individual recovers from the infection.
+- Infection, where a susceptible individual meets an infected individual and also becomes infected.
+- Recovery, where an infected individual recovers from the infection.
Each reaction is also associated with a specific rate (corresponding to a parameter).
-* *b*, the infection rate.
-* *k*, the recovery rate.
+- *b*, the infection rate.
+- *k*, the recovery rate.
We declare the model using the `@reaction_network` macro, and store it in the `sir_model` variable.
@@ -305,7 +305,6 @@ Some additional useful Pkg commands are:
!!! 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.
-
---
## Feedback
diff --git a/docs/src/introduction_to_catalyst/introduction_to_catalyst.md b/docs/src/introduction_to_catalyst/introduction_to_catalyst.md
index e5f6d1c3..73e8b482 100644
--- a/docs/src/introduction_to_catalyst/introduction_to_catalyst.md
+++ b/docs/src/introduction_to_catalyst/introduction_to_catalyst.md
@@ -2,7 +2,7 @@
In this tutorial we provide an introduction to using Catalyst to specify
chemical reaction networks, and then to solve ODE, jump, and SDE models
-generated from them [1]. At the end we show what mathematical rate laws and
+generated from them[^1]. At the end we show what mathematical rate laws and
transition rate functions (i.e. intensities or propensities) are generated by
Catalyst for ODE, SDE and jump process models. The [Mathematical Models Catalyst
can Generate](@ref math_models_in_catalyst) documentation illustrates the
@@ -437,4 +437,4 @@ A more detailed summary of the precise mathematical equations Catalyst can gener
## References
-1. [Torkel E. Loman, Yingbo Ma, Vasily Ilin, Shashi Gowda, Niklas Korsbo, Nikhil Yewale, Chris Rackauckas, Samuel A. Isaacson, *Catalyst: Fast and flexible modeling of reaction networks*, PLOS Computational Biology (2023).](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1011530)
+[^1]: [Torkel E. Loman, Yingbo Ma, Vasily Ilin, Shashi Gowda, Niklas Korsbo, Nikhil Yewale, Chris Rackauckas, Samuel A. Isaacson, *Catalyst: Fast and flexible modeling of reaction networks*, PLOS Computational Biology (2023).](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1011530)
diff --git a/docs/src/introduction_to_catalyst/math_models_intro.md b/docs/src/introduction_to_catalyst/math_models_intro.md
index bd34d295..cccf25da 100644
--- a/docs/src/introduction_to_catalyst/math_models_intro.md
+++ b/docs/src/introduction_to_catalyst/math_models_intro.md
@@ -46,7 +46,7 @@ a_k(\mathbf{X}(t)) = k \prod_{m=1}^M \frac{X_m(t) (X_m(t)-1) \dots (X_m(t)-\alph
for stochastic chemical kinetics jump process models.
-### Rate Law vs. Propensity Example:
+### Rate Law vs. Propensity Example
For the reaction $2A + B \overset{k}{\to} 3 C$ we would have
diff --git a/docs/src/inverse_problems/behaviour_optimisation.md b/docs/src/inverse_problems/behaviour_optimisation.md
index 1abbf8bb..bc3f864d 100644
--- a/docs/src/inverse_problems/behaviour_optimisation.md
+++ b/docs/src/inverse_problems/behaviour_optimisation.md
@@ -94,16 +94,16 @@ How to use Optimization.jl is discussed in more detail in [this tutorial](@ref o
If you use this functionality in your research, please cite the following paper to support the authors of the Optimization.jl package:
-```
+```bibtex
@software{vaibhav_kumar_dixit_2023_7738525,
- author = {Vaibhav Kumar Dixit and Christopher Rackauckas},
- month = mar,
- publisher = {Zenodo},
- title = {Optimization.jl: A Unified Optimization Package},
- version = {v3.12.1},
- doi = {10.5281/zenodo.7738525},
- url = {https://doi.org/10.5281/zenodo.7738525},
- year = 2023
+ author = {Vaibhav Kumar Dixit and Christopher Rackauckas},
+ month = mar,
+ publisher = {Zenodo},
+ title = {Optimization.jl: A Unified Optimization Package},
+ version = {v3.12.1},
+ doi = {10.5281/zenodo.7738525},
+ url = {https://doi.org/10.5281/zenodo.7738525},
+ year = 2023
}
```
diff --git a/docs/src/inverse_problems/global_sensitivity_analysis.md b/docs/src/inverse_problems/global_sensitivity_analysis.md
index 2802b070..6d134e0b 100644
--- a/docs/src/inverse_problems/global_sensitivity_analysis.md
+++ b/docs/src/inverse_problems/global_sensitivity_analysis.md
@@ -68,7 +68,6 @@ on the domain $10^β ∈ (-3.0,-1.0)$, $10^a ∈ (-2.0,0.0)$, $10^γ ∈ (-2.0,0
- Again, as [previously described in other inverse problem tutorials](@ref optimization_parameter_fitting_basics), when exploring a function over large parameter spaces, we will likely simulate our model for unsuitable parameter sets. To reduce time spent on these, and to avoid excessive warning messages, we provide the `maxiters = 100000` and `verbose = false` arguments to `solve`.
- As we have encountered in [a few other cases](@ref optimization_parameter_fitting_basics), the `gsa` function is not able to take parameter inputs of the map form usually used for Catalyst. Hence, as a first step in `peak_cases` we convert the parameter vector to this form. Next, we remember that the order of the parameters when we e.g. evaluate the GSA output, or set the parameter bounds, corresponds to the order used in `ps = [:β => p[1], :a => p[2], :γ => p[3]]`.
-
## [Sobol's method-based global sensitivity analysis](@id global_sensitivity_analysis_sobol)
The most common method for GSA is [Sobol's method](https://en.wikipedia.org/wiki/Variance-based_sensitivity_analysis). This can be carried out using:
@@ -137,7 +136,6 @@ As previously, we note that the peak number of infected cases is more sensitive
Generally, Morris's method is computationally less intensive, and has easier to interpret output, as compared to Sobol's method. However, if computational resources are available, Sobol's method is more comprehensive.
-
## [Other global sensitivity analysis methods](@id global_sensitivity_analysis_other_methods)
GlobalSensitivity also implements additional methods for GSA, more details on these can be found in the [package's documentation](https://docs.sciml.ai/GlobalSensitivity/stable/).
@@ -178,7 +176,7 @@ Here, the function's sensitivity is evaluated with respect to each output indepe
If you use this functionality in your research, [in addition to Catalyst](@ref doc_index_citation), please cite the following paper to support the authors of the GlobalSensitivity.jl package:
-```
+```bibtex
@article{dixit2022globalsensitivity,
title={GlobalSensitivity. jl: Performant and Parallel Global Sensitivity Analysis with Julia},
author={Dixit, Vaibhav Kumar and Rackauckas, Christopher},
diff --git a/docs/src/inverse_problems/optimization_ode_param_fitting.md b/docs/src/inverse_problems/optimization_ode_param_fitting.md
index ada84c7b..1ca55f61 100644
--- a/docs/src/inverse_problems/optimization_ode_param_fitting.md
+++ b/docs/src/inverse_problems/optimization_ode_param_fitting.md
@@ -83,6 +83,7 @@ nothing # hide
!!! note
Especially if you check Optimization.jl's documentation, you will note that objective functions have the `f(u,p)` form. This is because `OptimizationProblem`s (like e.g. `ODEProblem`s) can take both variables (which are varied during the optimisation procedure), but also parameters that are fixed. In our case, the *optimisation variables* correspond to our *model parameters*. Hence, our model parameter values (`p`) are the first argument (`u`). This is also why we find the optimisation solution (our optimised parameter set) in `opt_sol`'s `u` field. Our optimisation problem does not actually have any parameters, hence, the second argument of `objective_function` is unused (that is why we call it `_`, a name commonly indicating unused function arguments).
+<!-- markdownlint-disable-next-line MD046 -->
There are several modifications to our problem where it would actually have parameters. E.g. we might want to run the optimisation where one parameter has a known fixed value. If we then would like to rerun this for alternative fixed values, this value could be encoded as an `OptimizationProblem` parameter.
Finally, we can solve `optprob` to find the parameter set that best fits our data. Optimization.jl only provides a few optimisation methods natively. However, for each supported optimisation package, it provides a corresponding wrapper package to import that optimisation package for use with Optimization.jl. E.g., if we wish to use [NLopt.jl](https://github.com/JuliaOpt/NLopt.jl)'s [Nelder-Mead](https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method) method, we must install and import the OptimizationNLopt package. A summary of all, by Optimization.jl supported, optimisation packages can be found [here](https://docs.sciml.ai/Optimization/stable/#Overview-of-the-Optimizers). Here, we import the NLopt.jl package and uses it to minimise our objective function (thus finding a parameter set that fits the data):
@@ -104,7 +105,7 @@ Catalyst.PNG(plot(plt; fmt = :png, dpi = 200)) # hide
```
!!! note
- Here, a good exercise is to check the resulting parameter set and note that, while it creates a good fit to the data, it does not actually correspond to the original parameter set. Identifiability is a concept that studies how to deal with this problem.<!--NTS: re-add ref when identifiablity works again-->
+ Here, a good exercise is to check the resulting parameter set and note that, while it creates a good fit to the data, it does not actually correspond to the original parameter set. Identifiability is a concept that studies how to deal with this problem.<!--NTS: re-add ref when identifiability works again-->
Say that we instead would like to use a [genetic algorithm](https://en.wikipedia.org/wiki/Genetic_algorithm) approach, as implemented by the [Evolutionary.jl](https://github.com/wildart/Evolutionary.jl) package. In this case we can run:
@@ -261,16 +262,16 @@ end
If you use this functionality in your research, please cite the following paper to support the authors of the Optimization.jl package:
-```
+```bibtex
@software{vaibhav_kumar_dixit_2023_7738525,
- author = {Vaibhav Kumar Dixit and Christopher Rackauckas},
- month = mar,
- publisher = {Zenodo},
- title = {Optimization.jl: A Unified Optimization Package},
- version = {v3.12.1},
- doi = {10.5281/zenodo.7738525},
- url = {https://doi.org/10.5281/zenodo.7738525},
- year = 2023
+ author = {Vaibhav Kumar Dixit and Christopher Rackauckas},
+ month = mar,
+ publisher = {Zenodo},
+ title = {Optimization.jl: A Unified Optimization Package},
+ version = {v3.12.1},
+ doi = {10.5281/zenodo.7738525},
+ url = {https://doi.org/10.5281/zenodo.7738525},
+ year = 2023
}
```
diff --git a/docs/src/inverse_problems/petab_ode_param_fitting.md b/docs/src/inverse_problems/petab_ode_param_fitting.md
index 51e4726d..4fc4b0e5 100644
--- a/docs/src/inverse_problems/petab_ode_param_fitting.md
+++ b/docs/src/inverse_problems/petab_ode_param_fitting.md
@@ -1,6 +1,6 @@
# [Parameter Fitting for ODEs using PEtab.jl](@id petab_parameter_fitting)
-The [PEtab.jl package](https://github.com/sebapersson/PEtab.jl) implements the [PEtab format](https://petab.readthedocs.io/en/latest/) for fitting the parameters of deterministic CRN models to data [^1]. PEtab.jl both implements methods for creating cost functions (determining how well parameter sets fit to data), and for minimizing these cost functions. The PEtab approach covers most cases of fitting deterministic (ODE) models to data and is a good default choice when fitting reaction rate equation ODE models. This page describes how to combine PEtab.jl and Catalyst for parameter fitting, with the PEtab.jl package providing [a more extensive documentation](https://sebapersson.github.io/PEtab.jl/stable/) (this tutorial is partially an adaptation of this documentation).
+The [PEtab.jl package](https://github.com/sebapersson/PEtab.jl) implements the [PEtab format](https://petab.readthedocs.io/en/latest/) for fitting the parameters of deterministic CRN models to data[^1]. PEtab.jl both implements methods for creating cost functions (determining how well parameter sets fit to data), and for minimizing these cost functions. The PEtab approach covers most cases of fitting deterministic (ODE) models to data and is a good default choice when fitting reaction rate equation ODE models. This page describes how to combine PEtab.jl and Catalyst for parameter fitting, with the PEtab.jl package providing [a more extensive documentation](https://sebapersson.github.io/PEtab.jl/stable/) (this tutorial is partially an adaptation of this documentation).
While PEtab's interface generally is very flexible, there might be specific use-cases where it cannot create an appropriate cost-function. Here, it is recommended to instead look at using [Optimization.jl](@ref optimization_parameter_fitting).
@@ -108,7 +108,6 @@ measurements = DataFrame(obs_id = "obs_P", time = data_ts, measurement = data_va
Since, in our example, all measurements are of the same observable, we can set `obs_id="obs_P"`. However, it is also possible to [include measurements from several different observables](@ref petab_simulation_measurements_several_observables).
-
### Creating a PEtabModel
Finally, we combine all inputs in a single `PEtabModel`. To it, we also pass the initial conditions of our simulations (using the `speciemap` argument). It is also possible to have [initial conditions with uncertainty](@ref petab_simulation_initial_conditions_uncertainty), [that vary between different simulations](@ref petab_simulation_conditions), or [that we attempt to fit to the data](@ref petab_simulation_initial_conditions_fitted).
@@ -619,7 +618,7 @@ There exist several types of plots for both types of calibration results. More d
If you use this functionality in your research, [in addition to Catalyst](@ref doc_index_citation), please cite the following papers to support the authors of the PEtab.jl package (currently there is no article associated with this package) and the PEtab standard:
-```
+```bibtex
@misc{2023Petabljl,
author = {Ognissanti, Damiano AND Arutjunjan, Rafael AND Persson, Sebastian AND Hasselgren, Viktor},
title = {{2023Petabljl.jl}},
@@ -628,7 +627,7 @@ If you use this functionality in your research, [in addition to Catalyst](@ref d
}
```
-```
+```bibtex
@article{SchmiesterSch2021,
author = {Schmiester, Leonard AND Schälte, Yannik AND Bergmann, Frank T. AND Camba, Tacio AND Dudkin, Erika AND Egert, Janine AND Fröhlich, Fabian AND Fuhrmann, Lara AND Hauber, Adrian L. AND Kemmer, Svenja AND Lakrisenko, Polina AND Loos, Carolin AND Merkt, Simon AND Müller, Wolfgang AND Pathirana, Dilan AND Raimúndez, Elba AND Refisch, Lukas AND Rosenblatt, Marcus AND Stapor, Paul L. AND Städter, Philipp AND Wang, Dantong AND Wieland, Franz-Georg AND Banga, Julio R. AND Timmer, Jens AND Villaverde, Alejandro F. AND Sahle, Sven AND Kreutz, Clemens AND Hasenauer, Jan AND Weindl, Daniel},
journal = {PLOS Computational Biology},
diff --git a/docs/src/inverse_problems/structural_identifiability.md b/docs/src/inverse_problems/structural_identifiability.md
index 54f2abf3..8ea86933 100644
--- a/docs/src/inverse_problems/structural_identifiability.md
+++ b/docs/src/inverse_problems/structural_identifiability.md
@@ -117,7 +117,7 @@ assess_local_identifiability(gwo; measured_quantities = [:M], loglevel = Logging
We note that the results are consistent with those produced by `assess_identifiability` (with globally or locally identifiable quantities here all being assessed as at least locally identifiable).
-## [Finding identifiable functions](@id structural_identifiability_identifiabile_funcs)
+## [Finding identifiable functions](@id structural_identifiability_identifiable_funcs)
Finally, StructuralIdentifiability provides the `find_identifiable_functions` function. Rather than determining the identifiability of each parameter and unknown of the model, it finds a set of identifiable functions, such as any other identifiable expression of the model can be generated by these. Let us again consider the Goodwind oscillator, using the `find_identifiable_functions` function we find that identifiability can be reduced to five globally identifiable expressions:
@@ -177,7 +177,7 @@ is currently not possible. Hopefully this will be a supported feature in the fut
If you use this functionality in your research, please cite the following paper to support the authors of the StructuralIdentifiability package:
-```
+```bibtex
@article{structidjl,
author = {Dong, R. and Goodbrake, C. and Harrington, H. and Pogudin G.},
title = {Differential Elimination for Dynamical Models via Projections with Applications to Structural Identifiability},
diff --git a/docs/src/model_creation/chemistry_related_functionality.md b/docs/src/model_creation/chemistry_related_functionality.md
index 5a3d3d45..fc8d1254 100644
--- a/docs/src/model_creation/chemistry_related_functionality.md
+++ b/docs/src/model_creation/chemistry_related_functionality.md
@@ -5,7 +5,6 @@ While Catalyst has primarily been designed around the modelling of biological sy
- The `@compound` option, which enables the user to designate that a specific species is composed of certain subspecies.
- The `balance_reaction` function, which enables the user to balance a reaction so the same number of components occur on both sides.
-
## [Modelling with compound species](@id chemistry_functionality_compounds)
### [Creating compound species programmatically](@id chemistry_functionality_compounds_programmatic)
diff --git a/docs/src/model_creation/compositional_modeling.md b/docs/src/model_creation/compositional_modeling.md
index ad9fb9d7..2a84688c 100644
--- a/docs/src/model_creation/compositional_modeling.md
+++ b/docs/src/model_creation/compositional_modeling.md
@@ -213,7 +213,7 @@ parameters for the nucleus and cytosol, and assume we are working with species
having units of number of molecules. Rate constants will have their common
concentration units, i.e. if ``V`` denotes the volume of a compartment then
-| Reaction Type | Example | Rate Constant Units | Effective rate constant (units of per time)
+| Reaction Type | Example | Rate Constant Units | Effective rate constant (units of per time) |
|:----------: | :----------: | :----------: |:------------:|
| Zero order | ``\varnothing \overset{\alpha}{\to} A`` | concentration / time | ``\alpha V`` |
| First order | ``A \overset{\beta}{\to} B`` | (time)⁻¹ | ``\beta`` |
diff --git a/docs/src/model_creation/constraint_equations.md b/docs/src/model_creation/constraint_equations.md
index fd691183..356ce2eb 100644
--- a/docs/src/model_creation/constraint_equations.md
+++ b/docs/src/model_creation/constraint_equations.md
@@ -81,7 +81,6 @@ sol = solve(oprob, Tsit5())
plot(sol)
```
-
## [Coupling ODE constraints via extending a system](@id constraint_equations_coupling_constraints)
Finally, we could also construct our model by using compositional modeling. Here
@@ -143,7 +142,6 @@ sol = solve(oprob, Tsit5())
plot(sol)
```
-
## [Adding events](@id constraint_equations_events)
Our current model is unrealistic in assuming the cell will grow exponentially
diff --git a/docs/src/model_creation/dsl_advanced.md b/docs/src/model_creation/dsl_advanced.md
index 9ac67c1f..b3e22660 100644
--- a/docs/src/model_creation/dsl_advanced.md
+++ b/docs/src/model_creation/dsl_advanced.md
@@ -339,7 +339,7 @@ end
Running the code above will yield the following error:
-```
+```julia
LoadError: UndeclaredSymbolicError: Unrecognized variables A detected in reaction expression: "((k1, k2), A <--> B)". Since the flag @require_declaration is declared, all species must be explicitly declared with the @species macro.
```
@@ -553,7 +553,6 @@ species(rn)
!!! note
Setting spatial independent variables is primarily intended for the modelling of spatial systems on continuous domains. Catalyst's support for this is currently under development. Hence, the utility of specifying spatial independent variables is limited.
-
## [Setting reaction metadata](@id dsl_advanced_options_reaction_metadata)
It is possible to supply reactions with *metadata*, containing some additional information of the reaction. A reaction's metadata follows after its declaration (first using the metadata's name, then a `=`, then its value) and is encapsulated by `[]` (where individual entries are separated by `,`). Here, we add a `description` metadata to the reactions of a birth-death process:
diff --git a/docs/src/model_creation/dsl_basics.md b/docs/src/model_creation/dsl_basics.md
index 5d58995d..b2d52ad0 100644
--- a/docs/src/model_creation/dsl_basics.md
+++ b/docs/src/model_creation/dsl_basics.md
@@ -43,7 +43,7 @@ Here, you start with `@reaction_network begin`, next list all of the model's rea
Each reaction line declares, in order, the rate, the substrate(s), and the product(s). The rate is separated from the substrate(s) by a `,`, and the substrate(s) from the production by a `-->` (other arrows, however, are [also possible](@ref dsl_description_symbols_arrows)). In the above example, our model consists of two reactions. In the first one, `X` (the single substrate) becomes `Y` (the single product) at rate `2.0`. In the second reaction, `Y` becomes `X` at rate `1.0`.
-Finally, `rn = ` is used to store the model in the variable `rn` (a normal Julia variable, which does not need to be called `rn`).
+Finally, `rn =` is used to store the model in the variable `rn` (a normal Julia variable, which does not need to be called `rn`).
## [Defining parameters and species in the DSL](@id dsl_description_parameters_basics)
@@ -243,7 +243,6 @@ end
is not permitted (due to this notation's similarity to a bidirectional reaction). However, if multiples are provided for substrates and/or products, like `(k1,k2), (X1,X2) --> Y`, then bundling works.
-
## [Non-constant reaction rates](@id dsl_description_nonconstant_rates)
So far we have assumed that all reaction rates are constant (being either a number of a parameter). Non-constant rates that depend on one (or several) species are also possible. More generally, the rate can be any valid expression of parameters and species.
diff --git a/docs/src/model_creation/examples/hodgkin_huxley_equation.md b/docs/src/model_creation/examples/hodgkin_huxley_equation.md
index 29bc223e..fb201afa 100644
--- a/docs/src/model_creation/examples/hodgkin_huxley_equation.md
+++ b/docs/src/model_creation/examples/hodgkin_huxley_equation.md
@@ -101,7 +101,7 @@ action potential.
```@example hh1
tspan = (0.0, 50.0)
u₀ = [:V => -70, :m => 0.0, :h => 0.0, :n => 0.0,
- :m′ => 1.0, :n′ => 1.0, :h′ => 1.0]
+ :m′ => 1.0, :n′ => 1.0, :h′ => 1.0]
oprob = ODEProblem(hhmodel, u₀, tspan)
hhsssol = solve(oprob, Rosenbrock23())
nothing # hide
diff --git a/docs/src/model_creation/examples/noise_modelling_approaches.md b/docs/src/model_creation/examples/noise_modelling_approaches.md
index c54194ed..4f5d5176 100644
--- a/docs/src/model_creation/examples/noise_modelling_approaches.md
+++ b/docs/src/model_creation/examples/noise_modelling_approaches.md
@@ -124,7 +124,6 @@ plot(sol_inputnoise; idxs = :X)
Like in the previous two cases, this generates heterogeneous trajectories across our ensemble.
-
## [Investigating the mean of noisy oscillations](@id noise_modelling_approaches_model_noisy_oscillation_mean)
Finally, we will observe an interesting phenomenon for ensembles of stochastic oscillators. First, we create ensemble simulations with a larger number of trajectories.
diff --git a/docs/src/model_creation/examples/programmatic_generative_linear_pathway.md b/docs/src/model_creation/examples/programmatic_generative_linear_pathway.md
index ea5c20b0..dbfd1797 100644
--- a/docs/src/model_creation/examples/programmatic_generative_linear_pathway.md
+++ b/docs/src/model_creation/examples/programmatic_generative_linear_pathway.md
@@ -155,7 +155,6 @@ sol_n20 = solve(generate_oprob(20))
plot!(sol_n20; idxs = :Xend, label = "n = 20")
```
-
---
## References
diff --git a/docs/src/model_creation/examples/smoluchowski_coagulation_equation.md b/docs/src/model_creation/examples/smoluchowski_coagulation_equation.md
index e94a44f6..09fce9b8 100644
--- a/docs/src/model_creation/examples/smoluchowski_coagulation_equation.md
+++ b/docs/src/model_creation/examples/smoluchowski_coagulation_equation.md
@@ -81,7 +81,7 @@ We'll set the parameters and the initial condition that only monomers are presen
t = default_t()
@species (X(t))[1:N]
-# time-span
+# time span
if i == 1
tspan = (0.0, 2000.0)
elseif i == 2
@@ -164,5 +164,5 @@ plot!(ϕ, sol[3,:] / Nₒ, line = (:dot, 4, :purple), label = "Analytical sol--X
## References
1. [https://en.wikipedia.org/wiki/Smoluchowski\_coagulation\_equation](https://en.wikipedia.org/wiki/Smoluchowski_coagulation_equation)
-2. Scott, W. T. (1968). Analytic Studies of Cloud Droplet Coalescence I, Journal of Atmospheric Sciences, 25(1), 54-65. Retrieved Feb 18, 2021, from https://journals.ametsoc.org/view/journals/atsc/25/1/1520-0469\_1968\_025\_0054\_asocdc\_2\_0\_co\_2.xml
-3. Ian J. Laurenzi, John D. Bartels, Scott L. Diamond, A General Algorithm for Exact Simulation of Multicomponent Aggregation Processes, Journal of Computational Physics, Volume 177, Issue 2, 2002, Pages 418-449, ISSN 0021-9991, https://doi.org/10.1006/jcph.2002.7017.
+2. Scott, W. T. (1968). Analytic Studies of Cloud Droplet Coalescence I, Journal of Atmospheric Sciences, 25(1), 54-65. Retrieved Feb 18, 2021, from <https://journals.ametsoc.org/view/journals/atsc/25/1/1520-0469\_1968\_025\_0054\_asocdc\_2\_0\_co\_2.xml>
+3. Ian J. Laurenzi, John D. Bartels, Scott L. Diamond, A General Algorithm for Exact Simulation of Multicomponent Aggregation Processes, Journal of Computational Physics, Volume 177, Issue 2, 2002, Pages 418-449, ISSN 0021-9991, <https://doi.org/10.1006/jcph.2002.7017>.
diff --git a/docs/src/model_creation/functional_parameters.md b/docs/src/model_creation/functional_parameters.md
index 4a29287b..61637a02 100644
--- a/docs/src/model_creation/functional_parameters.md
+++ b/docs/src/model_creation/functional_parameters.md
@@ -41,7 +41,6 @@ plot(sol)
!!! note
For this simple example, $(2 + t)/(1 + t)$ could have been used directly as a reaction rate (or written as a normal function), technically making the functional parameter approach unnecessary. However, here we used this function as a simple example of how discrete data can be made continuous using DataInterpolations, and then have its values inserted using a (functional) parameter.
-
## [Inserting a customised, time-dependent, input](@id functional_parameters_circ_rhythm)
Let us now go through everything again, but providing some more details. Let us first consider the input parameter. We have previously described how a [time-dependent rate can model a circadian rhythm](@ref dsl_description_nonconstant_rates_time). For real applications, due to e.g. clouds, sunlight is not a perfect sine wave. Here, a common solution is to take real sunlight data from some location and use in the model. Here, we will create synthetic (noisy) data as our light input:
diff --git a/docs/src/model_creation/model_file_loading_and_export.md b/docs/src/model_creation/model_file_loading_and_export.md
index 34dfd5e1..af0643bd 100644
--- a/docs/src/model_creation/model_file_loading_and_export.md
+++ b/docs/src/model_creation/model_file_loading_and_export.md
@@ -34,7 +34,7 @@ cc_loaded # hide
Here, `include` is used to execute the Julia code from any file. This means that `save_reactionsystem` actually saves the model as executable code which re-generates the exact model which was saved (this is the reason why we use the ".jl" extension for the saved file). Indeed, we can confirm this if we check what is printed in the file:
-```
+```julia
let
# Independent variable:
@@ -108,7 +108,6 @@ plot(sol; idxs = [:mTetR, :mLacI, :mCI])
Note that, as all initial conditions and parameters have default values, we can provide empty vectors for these into our `ODEProblem`.
-
!!! note
It should be noted that .net files support a wide range of potential model features, not all of which are currently supported by ReactionNetworkImporters. Hence, there might be some .net files which `loadrxnetwork` will not be able to load.
@@ -160,14 +159,13 @@ Or
The advantage of these forms is that they offer a compact and very general way to represent a large class of CRNs. ReactionNetworkImporters have the functionality for converting matrices of these forms directly into Catalyst `ReactionSystem` models. Instructions on how to do this are available in [ReactionNetworkImporter's documentation](https://docs.sciml.ai/ReactionNetworkImporters/stable/#Loading-a-matrix-representation).
-
---
## [Citations](@id petab_citations)
If you use any of this functionality in your research, [in addition to Catalyst](@ref doc_index_citation), please cite the paper(s) corresponding to whichever package(s) you used:
-```
+```bibtex
@software{2022ReactionNetworkImporters,
author = {Isaacson, Samuel},
title = {{ReactionNetworkImporters.jl}},
@@ -176,7 +174,7 @@ If you use any of this functionality in your research, [in addition to Catalyst]
}
```
-```
+```bibtex
@software{2024SBMLImporter,
author = {Persson, Sebastian},
title = {{SBMLImporter.jl}},
@@ -185,16 +183,16 @@ If you use any of this functionality in your research, [in addition to Catalyst]
}
```
-```
+```bibtex
@article{LangJainRackauckas+2024,
- url = {https://doi.org/10.1515/jib-2024-0003},
- title = {SBMLToolkit.jl: a Julia package for importing SBML into the SciML ecosystem},
- title = {},
- author = {Paul F. Lang and Anand Jain and Christopher Rackauckas},
- pages = {20240003},
- journal = {Journal of Integrative Bioinformatics},
- doi = {doi:10.1515/jib-2024-0003},
- year = {2024},
- lastchecked = {2024-06-02}
+ url = {https://doi.org/10.1515/jib-2024-0003},
+ title = {SBMLToolkit.jl: a Julia package for importing SBML into the SciML ecosystem},
+ title = {},
+ author = {Paul F. Lang and Anand Jain and Christopher Rackauckas},
+ pages = {20240003},
+ journal = {Journal of Integrative Bioinformatics},
+ doi = {doi:10.1515/jib-2024-0003},
+ year = {2024},
+ lastchecked = {2024-06-02}
}
```
diff --git a/docs/src/model_creation/model_visualisation.md b/docs/src/model_creation/model_visualisation.md
index 3af4c448..96b12e07 100644
--- a/docs/src/model_creation/model_visualisation.md
+++ b/docs/src/model_creation/model_visualisation.md
@@ -90,7 +90,7 @@ Finally, a [network's reaction complexes](@ref network_analysis_reaction_complex
plot_complexes(brusselator)
```
-Here, reaction complexes are displayed as blue nodes, and reactions between complexes are displayed as black arrows. Red arrows indicate that the rate constantof a reaction has a species-dependence. Edges can be optionally labeled with their rate expressions by calling with the option `show_rate_labels`.
+Here, reaction complexes are displayed as blue nodes, and reactions between complexes are displayed as black arrows. Red arrows indicate that the rate constant of a reaction has a species-dependence. Edges can be optionally labeled with their rate expressions by calling with the option `show_rate_labels`.
```@example visualisation_graphs
plot_complexes(brusselator, show_rate_labels = true)
diff --git a/docs/src/model_creation/programmatic_CRN_construction.md b/docs/src/model_creation/programmatic_CRN_construction.md
index 4343ab2f..d2f92af5 100644
--- a/docs/src/model_creation/programmatic_CRN_construction.md
+++ b/docs/src/model_creation/programmatic_CRN_construction.md
@@ -208,7 +208,7 @@ This ensured they were properly treated as species and not parameters. See the
The [Catalyst.jl API](@ref api) provides a large variety of functionality for
querying properties of a reaction network. Here we go over a few of the most
-useful basic functions. Given the `repressillator` defined above we have that
+useful basic functions. Given the `repressilator` defined above we have that
```@example ex
species(repressilator)
diff --git a/docs/src/model_simulation/examples/interactive_brusselator_simulation.md b/docs/src/model_simulation/examples/interactive_brusselator_simulation.md
index 12d3c763..c5352236 100644
--- a/docs/src/model_simulation/examples/interactive_brusselator_simulation.md
+++ b/docs/src/model_simulation/examples/interactive_brusselator_simulation.md
@@ -2,7 +2,6 @@
Catalyst can utilize the [GLMakie.jl](https://github.com/JuliaPlots/GLMakie.jl) package for creating interactive visualizations of your reaction network dynamics. This tutorial provides a step-by-step guide to creating an interactive visualization of the Brusselator model, building upon the basic [Brusselator](@ref basic_CRN_library_brusselator) example.
-
## [Setting up the Brusselator model](@id setup_brusselator)
Let's again use the oscillating Brusselator model, extending the basic simulation [plotting](@ref simulation_plotting) workflow we saw earlier.
diff --git a/docs/src/model_simulation/finite_state_projection_simulation.md b/docs/src/model_simulation/finite_state_projection_simulation.md
index 501795fa..6cddea0c 100644
--- a/docs/src/model_simulation/finite_state_projection_simulation.md
+++ b/docs/src/model_simulation/finite_state_projection_simulation.md
@@ -219,7 +219,6 @@ heatmap(0:24, 0:24, ss_jump ./length(esol); xguide = "X₂", yguide = "X")
Here we used an ensemble [output function](@ref activation_time_distribution_measurement) to only save each simulation's final state (and plot these using `heatmap`).
-
---
## References
diff --git a/docs/src/model_simulation/ode_simulation_performance.md b/docs/src/model_simulation/ode_simulation_performance.md
index 448ef49c..7b519360 100644
--- a/docs/src/model_simulation/ode_simulation_performance.md
+++ b/docs/src/model_simulation/ode_simulation_performance.md
@@ -1,7 +1,7 @@
# [Advice for Performant ODE Simulations](@id ode_simulation_performance)
We have previously described how to perform ODE simulations of *chemical reaction network* (CRN) models. These simulations are typically fast and require little additional consideration. However, when a model is simulated many times (e.g. as a part of solving an inverse problem), or is very large, simulation run
-times may become noticeable. Here we will give some advice on how to improve performance for these cases [^1].
+times may become noticeable. Here we will give some advice on how to improve performance for these cases[^1].
Generally, there are few good ways to, before a simulation, determine the best options. Hence, while we below provide several options, if you face an application for which reducing run time is critical (e.g. if you need to simulate the same ODE many times), it might be required to manually trial these various options to see which yields the best performance ([BenchmarkTools.jl's](https://github.com/JuliaCI/BenchmarkTools.jl) `@btime` macro is useful for this purpose). It should be noted that the default options typically perform well, and it is primarily for large models where investigating alternative options is worthwhile. All ODE simulations of Catalyst models are performed using the OrdinaryDiffEq.jl package, [which documentation](https://docs.sciml.ai/DiffEqDocs/stable/) provides additional advice on performance.
@@ -62,7 +62,6 @@ Generally, ODE solvers can be divided into [*explicit* and *implicit* solvers](h
Finally, we should note that stiffness is not tied to the model equations only. If we change the parameter values of our previous Brusselator model to `[:A => 1.0, :B => 4.0]`, the non-stiff `Tsit5` solver can successfully simulate it.
-
## [ODE solver selection](@id ode_simulation_performance_solvers)
OrdinaryDiffEq implements an unusually large number of ODE solvers, with the performance of the simulation heavily depending on which one is chosen. These are provided as the second argument to the `solve` command, e.g. here we use the `Tsit5` solver to simulate a simple [birth-death process](@ref basic_CRN_library_bd):
@@ -119,7 +118,6 @@ time and error. Benchmarks comparing solver performance (by plotting the run tim
Generally, whether solution error is a consideration depends on the application. If you want to compute the trajectory of an expensive space probe as it is sent from Earth, to slingshot Jupiter, and then reach Pluto a few years later, ensuring a minimal error will be essential. However, if you want to simulate a simple CRN to determine whether it oscillates for a given parameter set, a small error will not constitute a problem. An important aspect with regard to error is that it affects the selection of the optimal solver. E.g. if tolerance is low (generating larger errors) the `Rosenbrock23` method performs well for small, stiff, problems (again, more details can be found in [OrdinaryDiffEq's documentation](https://docs.sciml.ai/DiffEqDocs/stable/solvers/ode_solve/)).
-
## [Jacobian computation options for implicit solvers](@id ode_simulation_performance_jacobian)
As [previously mentioned](@ref ode_simulation_performance_stiffness), implicit ODE solvers require the computation of the system's [*Jacobian*](https://en.wikipedia.org/wiki/Jacobian_matrix_and_determinant). The reason is (roughly) that, in each time step, these solvers need to solve a non-linear equation to find the simulation's value at the next timestep (unlike explicit solvers, which compute the value at the next time step directly). Typically this is done using [the Newton-Raphson method](https://en.wikipedia.org/wiki/Newton%27s_method), which requires the Jacobian. Especially for large systems, this can be computationally expensive (and a potential strain on available memory), in which case one might consider various Jacobian-computation options (as described below). A throughout tutorial on simulating a large, stiff, ODE can be found [here](https://docs.sciml.ai/DiffEqDocs/stable/tutorials/advanced_ode_example/#stiff).
@@ -207,7 +205,6 @@ Finally, we note that when using preconditioners with a matrix-free method (like
Generally, the use of preconditioners is only recommended for advanced users who are familiar with the concepts. However, for large systems, if performance is essential, they can be worth looking into.
-
## [Elimination of system conservation laws](@id ode_simulation_performance_conservation_laws)
Previously, we have described how Catalyst, when it generates ODEs, is able to [detect and eliminate conserved quantities](@ref conservation_laws). In certain cases, doing this can improve performance. E.g. in the following example we will eliminate the single conserved quantity in a [two-state model](@ref basic_CRN_library_two_states). This results in a differential algebraic equation with a single differential equation and a single algebraic equation (as opposed to two differential equations). However, as the algebraic equation is fully determined by the ODE solution, Catalyst moves it to be an observable and our new system therefore only contains one ODE that must be solved numerically. Conservation laws can be eliminated by providing the `remove_conserved = true` option to `ODEProblem`:
@@ -230,7 +227,6 @@ nothing # hide
Conservation law elimination is not expected to ever impact performance negatively; it simply results in a (possibly) lower-dimensional system of ODEs to solve. However, eliminating conserved species may have minimal performance benefits; it is model-dependent whether elimination results in faster ODE solving times and/or increased solution accuracy.
-
## [Parallelisation on CPUs and GPUs](@id ode_simulation_performance_parallelisation)
Whenever an ODE is simulated a large number of times (e.g. when investigating its behaviour for different parameter values), the best way to improve performance is to [parallelise the simulation over multiple processing units](https://en.wikipedia.org/wiki/Parallel_computing). Indeed, an advantage of the Julia programming language is that it was designed after the advent of parallel computing, making it well-suited for this task. Roughly, parallelisation can be divided into parallelisation on [CPUs](https://en.wikipedia.org/wiki/Central_processing_unit) and on [GPUs](https://en.wikipedia.org/wiki/General-purpose_computing_on_graphics_processing_units). CPU parallelisation is most straightforward, while GPU parallelisation requires specialised ODE solvers (which Catalyst have access to).
@@ -415,14 +411,13 @@ Just like OrdinaryDiffEq is able to utilise parallel CPU processes to speed up t
For more information on differential equation simulations on GPUs in Julia, please read [DiffEqGPU's documentation](https://docs.sciml.ai/DiffEqGPU/stable/). Furthermore, if performance is critical, [this tutorial](https://docs.sciml.ai/DiffEqGPU/stable/tutorials/lower_level_api/) provides information on how to redesign your simulation code to make it more suitable for GPU simulations.
-
---
## Citation
If you use GPU simulations in your research, please cite the following paper to support the authors of the DiffEqGPU package:
-```
+```bibtex
@article{utkarsh2024automated,
title={Automated translation and accelerated solving of differential equations on multiple GPU platforms},
author={Utkarsh, Utkarsh and Churavy, Valentin and Ma, Yingbo and Besard, Tim and Srisuma, Prakitr and Gymnich, Tim and Gerlach, Adam R and Edelman, Alan and Barbastathis, George and Braatz, Richard D and others},
diff --git a/docs/src/model_simulation/simulation_introduction.md b/docs/src/model_simulation/simulation_introduction.md
index 09f40ab1..3d440b48 100644
--- a/docs/src/model_simulation/simulation_introduction.md
+++ b/docs/src/model_simulation/simulation_introduction.md
@@ -127,7 +127,6 @@ Some additional considerations:
- If a model without parameters has been declared, only the first three arguments must be provided to `ODEProblem`.
- While the first value of `tspan` will almost always be `0.0`, other starting times (both negative and positive) are possible.
-
### [Designating solvers and solver options](@id simulation_intro_solver_options)
While good defaults are generally selected, OrdinaryDiffEq enables the user to customise simulations through a long range of options that can be provided to the `solve` function. This includes specifying a [solver algorithm](https://en.wikipedia.org/wiki/Numerical_methods_for_ordinary_differential_equations), which can be provided as a second argument to `solve` (if none is provided, a suitable choice is automatically made). E.g. here we specify that the `Rodas5P` method should be used:
@@ -276,7 +275,7 @@ We note that this approach also enables us to successfully simulate the SDE we p
Generally, using a smaller fixed `dt` provides a more exact simulation, but also increases simulation runtime.
-### [Scaling the noise in the chemical Langevin equation](@id simulation_intro_SDEs_noise_saling)
+### [Scaling the noise in the chemical Langevin equation](@id simulation_intro_SDEs_noise_scaling)
When using the CLE to generate SDEs from a CRN, it can sometimes be desirable to scale the magnitude of the noise. This can be done by introducing a *noise scaling term*, with each noise term generated by the CLE being multiplied with this term. A noise scaling term can be set using the `@default_noise_scaling` option:
@@ -432,25 +431,25 @@ plot(sol; idxs = :P, lw = 2)
When you simulate Catalyst models in your research, please cite the corresponding paper(s) to support the simulation package authors. For ODE simulations:
-```
+```bibtex
@article{DifferentialEquations.jl-2017,
- author = {Rackauckas, Christopher and Nie, Qing},
- doi = {10.5334/jors.151},
- journal = {The Journal of Open Research Software},
- keywords = {Applied Mathematics},
- note = {Exported from https://app.dimensions.ai on 2019/05/05},
- number = {1},
- pages = {},
- title = {DifferentialEquations.jl – A Performant and Feature-Rich Ecosystem for Solving Differential Equations in Julia},
- url = {https://app.dimensions.ai/details/publication/pub.1085583166 and http://openresearchsoftware.metajnl.com/articles/10.5334/jors.151/galley/245/download/},
- volume = {5},
- year = {2017}
+ author = {Rackauckas, Christopher and Nie, Qing},
+ doi = {10.5334/jors.151},
+ journal = {The Journal of Open Research Software},
+ keywords = {Applied Mathematics},
+ note = {Exported from https://app.dimensions.ai on 2019/05/05},
+ number = {1},
+ pages = {},
+ title = {DifferentialEquations.jl – A Performant and Feature-Rich Ecosystem for Solving Differential Equations in Julia},
+ url = {https://app.dimensions.ai/details/publication/pub.1085583166 and http://openresearchsoftware.metajnl.com/articles/10.5334/jors.151/galley/245/download/},
+ volume = {5},
+ year = {2017}
}
```
For SDE simulations:
-```
+```bibtex
@article{rackauckas2017adaptive,
title={Adaptive methods for stochastic differential equations via natural embeddings and rejection sampling with memory},
author={Rackauckas, Christopher and Nie, Qing},
@@ -465,19 +464,20 @@ For SDE simulations:
For jump simulations:
-```
+```bibtex
@misc{2022JumpProcesses,
author = {Isaacson, S. A. and Ilin, V. and Rackauckas, C. V.},
title = {{JumpProcesses.jl}},
howpublished = {\url{https://github.com/SciML/JumpProcesses.jl/}},
year = {2022}
}
+
@misc{zagatti_extending_2023,
- title = {Extending {JumpProcess}.jl for fast point process simulation with time-varying intensities},
- url = {http://arxiv.org/abs/2306.06992},
- doi = {10.48550/arXiv.2306.06992},
- publisher = {arXiv},
- author = {Zagatti, Guilherme Augusto and Isaacson, Samuel A. and Rackauckas, Christopher and Ilin, Vasily and Ng, See-Kiong and Bressan, Stéphane},
- year = {2023},
+ title = {Extending {JumpProcess}.jl for fast point process simulation with time-varying intensities},
+ url = {http://arxiv.org/abs/2306.06992},
+ doi = {10.48550/arXiv.2306.06992},
+ publisher = {arXiv},
+ author = {Zagatti, Guilherme Augusto and Isaacson, Samuel A. and Rackauckas, Christopher and Ilin, Vasily and Ng, See-Kiong and Bressan, Stéphane},
+ year = {2023},
}
```
diff --git a/docs/src/network_analysis/crn_theory.md b/docs/src/network_analysis/crn_theory.md
index f1c82ab0..2d9d93f7 100644
--- a/docs/src/network_analysis/crn_theory.md
+++ b/docs/src/network_analysis/crn_theory.md
@@ -78,7 +78,7 @@ The graphs of the reaction complexes in the two sub-networks are then
and,
```@example s1b
- plot_complexes(subnets[2])
+ plot_complexes(subnets[2])
```
## [Deficiency of the network](@id network_analysis_structural_aspects_deficiency)
@@ -141,12 +141,11 @@ reactioncomplexes(rn)
δ = deficiency(rn)
```
-Quoting Feinberg [^1]
+Quoting Feinberg[^1]
> Deficiency zero networks are ones for which the reaction vectors [i.e. net
> stoichiometry vectors] are as independent as the partition of complexes into
> linkage classes will allow.
-
## [Reversibility of the network](@id network_analysis_structural_aspects_reversibility)
A reaction network is *reversible* if the "arrows" of the reactions are
diff --git a/docs/src/network_analysis/odes.md b/docs/src/network_analysis/odes.md
index 913ffb69..4afdd652 100644
--- a/docs/src/network_analysis/odes.md
+++ b/docs/src/network_analysis/odes.md
@@ -9,7 +9,7 @@ Network Theory*[^1] for more discussion about the concepts on this page.
Note, currently API functions for network analysis and conservation law analysis
do not work with constant species (which are generated by SBML, and can be [declared
-in Catalyst as well](@ref dsl_advanced_options_constant_species).
+in Catalyst as well](@ref dsl_advanced_options_constant_species)).
## [Network representation of the Repressilator `ReactionSystem`](@id network_analysis_repressilator_representation)
diff --git a/docs/src/spatial_modelling/lattice_reaction_systems.md b/docs/src/spatial_modelling/lattice_reaction_systems.md
index 4c9da8a9..5b5bfd71 100644
--- a/docs/src/spatial_modelling/lattice_reaction_systems.md
+++ b/docs/src/spatial_modelling/lattice_reaction_systems.md
@@ -14,7 +14,6 @@ Features for which support is planned in future updates include:
This tutorial introduces spatial modelling on discrete domains, here called lattices. It describes the basics of creating and simulating such models. To do so, it uses ODE simulations as examples. Additional tutorials provide further details on how to interact with [spatial simulation structures](@ref lattice_simulation_plotting) and [plot spatial simulations](@ref lattice_simulation_plotting), and also provide further details on [ODE](@ref spatial_lattice_ode_simulations) and [jump](@ref spatial_lattice_jump_simulations) simulations, respectively.
-
## [Basic example of a spatial simulation on a discrete domain](@id spatial_lattice_modelling_intro_example)
To perform discrete-space spatial simulations, the user must first define a [`LatticeReactionSystem`](@ref). These combine:
diff --git a/docs/src/spatial_modelling/lattice_simulation_structure_ interaction.md b/docs/src/spatial_modelling/lattice_simulation_structure_ interaction.md
index 489ef472..7bf894ec 100644
--- a/docs/src/spatial_modelling/lattice_simulation_structure_ interaction.md
+++ b/docs/src/spatial_modelling/lattice_simulation_structure_ interaction.md
@@ -150,8 +150,7 @@ There are two different circumstances when `rebuild_lat_internals!` must be call
Parameter values of integrators can be interfaced with just like for problems (this is primarily relevant when using [*callbacks*](https://docs.sciml.ai/DiffEqDocs/stable/features/callback_functions/)). Again, after doing so, the `rebuild_lat_internals!` function might need to be applied to the integrator.
-
-### [Retrieving and updatingedge parameter values in problems and integrators](@id lattice_simulation_structure_interaction_prob_int_parameters_edge_ps)
+### [Retrieving and updating edge parameter values in problems and integrators](@id lattice_simulation_structure_interaction_prob_int_parameters_edge_ps)
The `lat_getp` and `lat_setp!` functions cannot currently be applied to [edge parameters](@ref spatial_lattice_modelling_intro_simulation_edge_parameters). Instead, to access the value of an edge parameter, use
diff --git a/docs/src/steady_state_functionality/bifurcation_diagrams.md b/docs/src/steady_state_functionality/bifurcation_diagrams.md
index d27c5a21..0b1e004d 100644
--- a/docs/src/steady_state_functionality/bifurcation_diagrams.md
+++ b/docs/src/steady_state_functionality/bifurcation_diagrams.md
@@ -155,7 +155,6 @@ Finally, for additional clarity, we reiterate the purpose of the two `u` argumen
- `u_guess`: A guess of the initial steady states (which BifurcationKit uses to find its starting point). Typically, most trivial guesses work (e.g. setting all species concentrations to `1.0`). `u_guess` *does not* have to fulfil the conserved concentrations provided in `u0`.
- `u0`: Used to compute the concentrations of any conserved quantities (e.g. in our example $X + Xp = 1.0$). Technically, values are only required for species that are involved in conservation laws (in our case we do not need to provide a value for $K$). However, sometimes determining which species are actually involved in conservation laws can be difficult, and it might be easier to simply provide concentrations for all species.
-
---
## [Citation](@id bifurcationkit_periodic_orbits_citation)
diff --git a/docs/src/steady_state_functionality/dynamical_systems.md b/docs/src/steady_state_functionality/dynamical_systems.md
index 6c82b4ce..46d39a8a 100644
--- a/docs/src/steady_state_functionality/dynamical_systems.md
+++ b/docs/src/steady_state_functionality/dynamical_systems.md
@@ -145,14 +145,13 @@ Here, all Lyapunov exponents are negative, confirming that the brusselator is no
More details on how to compute Lyapunov exponents using DynamicalSystems.jl can be found [here](https://juliadynamics.github.io/ChaosTools.jl/stable/lyapunovs/). A full overview of tools for analysing chaotic behaviours (using the "ChaosTools.jl subpackage) can be found [here](https://juliadynamics.github.io/ChaosTools.jl/stable/).
-
---
## [Citations](@id dynamical_systems_citations)
If you use this functionality in your research, [in addition to Catalyst](@ref doc_index_citation), please cite the following paper to support the author of the DynamicalSystems.jl package:
-```
+```bibtex
@article{DynamicalSystems.jl-2018,
doi = {10.21105/joss.00598},
url = {https://doi.org/10.21105/joss.00598},
@@ -167,13 +166,11 @@ If you use this functionality in your research, [in addition to Catalyst](@ref d
}
```
-
---
## Learning more
-If you want to learn more about analysing dynamical systems, including chaotic behaviour, see the textbook [Nonlinear Dynamics](https://link.springer.com/book/10.1007/978-3-030-91032-7). It utilizes DynamicalSystems.jl and provides a concise, hands-on approach to learning nonlinear dynamics and analysing dynamical systems [^3].
-
+If you want to learn more about analysing dynamical systems, including chaotic behaviour, see the textbook [Nonlinear Dynamics](https://link.springer.com/book/10.1007/978-3-030-91032-7). It utilizes DynamicalSystems.jl and provides a concise, hands-on approach to learning nonlinear dynamics and analysing dynamical systems[^3].
---
diff --git a/docs/src/steady_state_functionality/examples/bifurcationkit_codim2.md b/docs/src/steady_state_functionality/examples/bifurcationkit_codim2.md
index 879124a6..09cfd6d6 100644
--- a/docs/src/steady_state_functionality/examples/bifurcationkit_codim2.md
+++ b/docs/src/steady_state_functionality/examples/bifurcationkit_codim2.md
@@ -141,7 +141,6 @@ sol_osc = OrdinaryDiffEqDefault.solve(oprob_osc)
plot(plot(sol_nosc; title = "No oscillation"), plot(sol_osc; title = "Oscillation"); size = (1000, 400), lw = 4)
```
-
---
## [Citation](@id bifurcationkit_periodic_orbits_citation)
diff --git a/docs/src/steady_state_functionality/examples/bifurcationkit_periodic_orbits.md b/docs/src/steady_state_functionality/examples/bifurcationkit_periodic_orbits.md
index e51a6b06..28ad01be 100644
--- a/docs/src/steady_state_functionality/examples/bifurcationkit_periodic_orbits.md
+++ b/docs/src/steady_state_functionality/examples/bifurcationkit_periodic_orbits.md
@@ -117,7 +117,6 @@ plot(br_po, vars = (:param, :period); xguide = bif_par, yguide = "Period length"
In the plot we see that the period starts at around $18$ time units, and slowly increase with $v$.
-
---
## [Citation](@id bifurcationkit_periodic_orbits_citation)
diff --git a/docs/src/steady_state_functionality/homotopy_continuation.md b/docs/src/steady_state_functionality/homotopy_continuation.md
index 67ce42dd..fcf28dc3 100644
--- a/docs/src/steady_state_functionality/homotopy_continuation.md
+++ b/docs/src/steady_state_functionality/homotopy_continuation.md
@@ -11,7 +11,6 @@ integer Hill exponents). The roots of these can reliably be found through a
Catalyst contains a special homotopy continuation extension that is loaded whenever HomotopyContinuation.jl is. This exports a single function, `hc_steady_states`, that can be used to find the steady states of any `ReactionSystem` structure.
-
For this tutorial, we will use the [Wilhelm model](@ref basic_CRN_library_wilhelm) (which
demonstrates bistability in a small chemical reaction network). We declare the
model and the parameter set for which we want to find the steady states:
@@ -69,14 +68,13 @@ hc_steady_states(two_state_model, ps; u0)
- When providing initial conditions to compute conservation laws, values are only required for those species that are part of conserved quantities. If this set of species is unknown, it is recommended to provide initial conditions for all species.
- Additional arguments provided to `hc_steady_states` are automatically passed to HomotopyContinuation's `solve` command. Use e.g. `show_progress = false` to disable the progress bar.
-
---
## [Citation](@id homotopy_continuation_citation)
If you use this functionality in your research, please cite the following paper to support the authors of the HomotopyContinuation package:
-```
+```bibtex
@inproceedings{HomotopyContinuation.jl,
title={{H}omotopy{C}ontinuation.jl: {A} {P}ackage for {H}omotopy {C}ontinuation in {J}ulia},
author={Breiding, Paul and Timme, Sascha},
@@ -87,11 +85,10 @@ If you use this functionality in your research, please cite the following paper
}
```
-
---
## References
-[^1]: [Andrew J Sommese, Charles W Wampler *The Numerical Solution of Systems of Polynomials Arising in Engineering and Science*, World Scientific (2005).](https://www.worldscientific.com/worldscibooks/10.1142/5763#t=aboutBook)
+[^1]: [Andrew J. Sommese, Charles W. Wampler *The Numerical Solution of Systems of Polynomials Arising in Engineering and Science*, World Scientific (2005).](https://www.worldscientific.com/worldscibooks/10.1142/5763#t=aboutBook)
[^2]: [Daniel J. Bates, Paul Breiding, Tianran Chen, Jonathan D. Hauenstein, Anton Leykin, Frank Sottile, *Numerical Nonlinear Algebra*, arXiv (2023).](https://arxiv.org/abs/2302.08585)
[^3]: [Paul Breiding, Sascha Timme, *HomotopyContinuation.jl: A Package for Homotopy Continuation in Julia*, International Congress on Mathematical Software (2018).](https://link.springer.com/chapter/10.1007/978-3-319-96418-8_54)
diff --git a/docs/src/steady_state_functionality/nonlinear_solve.md b/docs/src/steady_state_functionality/nonlinear_solve.md
index 330b0877..9f4b887f 100644
--- a/docs/src/steady_state_functionality/nonlinear_solve.md
+++ b/docs/src/steady_state_functionality/nonlinear_solve.md
@@ -127,7 +127,7 @@ ssprob = SteadyStateProblem(dimer_production, u0, p)
nothing # hide
```
-Finally, we can find the steady states using the `solver` command. Since `SteadyStateProblem`s are solved through forward ODE simulation, we must load the sublibrary of the [OrdinaryDiffEq.jl](https://github.com/SciML/OrdinaryDiffEq.jl) package that corresponds to the [selected ODE solver](@ref simulation_intro_solver_options). Any available ODE solver can be used, however, it has to be encapsulated by the `DynamicSS()` function. E.g. here we use the `Rodas5P` solver which is loaded from the `OrdinaryDiffEqRosenbrock` sublibrary:
+Finally, we can find the steady states using the `solver` command. Since `SteadyStateProblem`s are solved through forward ODE simulation, we must load the sub-library of the [OrdinaryDiffEq.jl](https://github.com/SciML/OrdinaryDiffEq.jl) package that corresponds to the [selected ODE solver](@ref simulation_intro_solver_options). Any available ODE solver can be used, however, it has to be encapsulated by the `DynamicSS()` function. E.g. here we use the `Rodas5P` solver which is loaded from the `OrdinaryDiffEqRosenbrock` sub-library:
(which requires loading the SteadyStateDiffEq package).
@@ -161,14 +161,13 @@ nothing # hide
However, especially when the forward ODE simulation approach is used, it is recommended to use the problem type which corresponds to the intended solver.
-
---
## [Citations](@id nonlinear_solve_citation)
If you use this functionality in your research, [in addition to Catalyst](@ref doc_index_citation), please cite the following paper to support the authors of the NonlinearSolve.jl package:
-```
+```bibtex
@article{pal2024nonlinearsolve,
title={NonlinearSolve. jl: High-Performance and Robust Solvers for Systems of Nonlinear Equations in Julia},
author={Pal, Avik and Holtorf, Flemming and Larsson, Axel and Loman, Torkel and Schaefer, Frank and Qu, Qingyu and Edelman, Alan and Rackauckas, Chris and others},
@@ -177,7 +176,6 @@ If you use this functionality in your research, [in addition to Catalyst](@ref d
}
```
-
---
## References
diff --git a/docs/src/v14_migration_guide.md b/docs/src/v14_migration_guide.md
index de41f404..69a3a6ee 100644
--- a/docs/src/v14_migration_guide.md
+++ b/docs/src/v14_migration_guide.md
@@ -255,7 +255,7 @@ This bug was likely present on earlier versions as well, but was only recently d
In early versions of Catalyst, parameters and species were provided as vectors (e.g. `[1.0, 2.0]`) rather than maps (e.g. `[p => 1.0, d => 2.0]`). While we previously *strongly* recommended users to use the map form (or they might produce unintended results), the vector form was still supported (technically). Due to recent internal ModelingToolkit updates, the purely numeric form is no longer supported and should never be used -- it will potentially lead to incorrect values for parameters and/or initial conditions. Note that if `rn` is a complete `ReactionSystem` you can now specify such mappings via `[rn.p => 1.0, rn.d => 2.0]`.
-*Users should never use vector-forms to represent parameter and species values*
+*Users should never use vector-forms to represent parameter and species values.* <!-- markdownlint-disable-line MD036 -->
#### Additional deprecated functions
diff --git a/test/upstream/mtk_problem_inputs.jl b/test/upstream/mtk_problem_inputs.jl
index 35497e16..2167a18d 100644
--- a/test/upstream/mtk_problem_inputs.jl
+++ b/test/upstream/mtk_problem_inputs.jl
@@ -284,7 +284,7 @@ begin
(:p => [4.0, 5.0], :d => [0.2, 0.5]),
]
- # Declares a timespan.
+ # Declares a time span.
tspan = (0.0, 10.0)
endSo if you would jump over your shadows and would accept the formatting changes, the other changes won't be lost ... (if you are not willing to invest the time of cherry-picking and resolving the merge conflicts yourself). Looking forward to your answer ... |
|
Error while trying to register: Register Failed |
Member
|
I think the fundamental problem is that both me and Sam are really quite busy right now, and have limited time avaiable for the package. So we'd rather spend the limited time we have to sort out various essential stuff to actually ensure that the package is up and running, rather than reading through formatting changes that don't have any direct impact. I.e. sorting out stuff like #1339 (which, once it is sorted out, any further PRs would need to be based upon to actually pass CI). So either we have really straightforward changes we can quickly check (i.e. fixing obvious spelling mistakes), or we will simply have to take anything that requires non-trivial reviewing after #1339 and probably also #1322 |
Contributor
Author
|
Then the decision is made. I'll also invest my time in something else now. I leave this PR open and it is up to you to close it if you are sure you will not merge it. If you should invest the time to have a(nother) look: Assuming you "trust" me that I didn't do any harm with the three "whitespace" commits, it took me less than 3 minutes to go through the provided patch in my previous comment ... |
Member
|
I’m going to close this then. If at any point you’d like to submit a PR without the white space changes we will happily review it. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
4 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Feel free to cherry-pick.
Now follow some open questions or open points which I summarize here as tasks, so they can be checked when done.
$syntax$$syntax(Code) Spell Checker
You write to use a spell checker,
Catalyst.jl/docs/src/devdocs/dev_guide.md
Lines 54 to 55 in 64c117f
but I can't find a dictionary file in the repo for all the unknown words. Is that intended?
missing link destination
In
Catalyst.jl/docs/src/steady_state_functionality/dynamical_systems.md
Line 94 in 64c117f
[Brusselator]should either be[Brusselator](@ref basic_CRN_library_brusselator)or[Brusselator](https://en.wikipedia.org/wiki/Brusselator).LaTeX stuff
$syntaxWhen I am not mistaken, the
$syntax shouldn't be used (any more), right? But there are plenty of (remaining) instances likeCatalyst.jl/docs/src/introduction_to_catalyst/catalyst_for_new_julia_users.md
Line 80 in 64c117f
Instead, according to the "Markdown LaTeX" section of the Julia manual the double backtick syntax should be used
``.Is it intentional that some files still use the
$syntax?$$syntaxThere also is one remaining instance of
$$atCatalyst.jl/docs/src/model_creation/examples/hodgkin_huxley_equation.md
Line 29 in 64c117f
which should be replaced with a ````
mathblock fenced block.line breaks vs. no line breaks
Some files don't have line breaks inside paragraphs -- like the Introduction to Catalyst and Julia for New Julia users) --, but some file have -- like the following file/section Introduction to Catalyst.
Should this be harmonized? And if yes, to which style?
other/wrong ref/cite style
Please have a look at the "Smoluchowski Coagulation Equation" section.
No footnote syntax
There isn't used the "footnote" syntax for the references and the citations (
[^1]). This is the only (remaining) file with such a style.Ref [1] not used
Currently the link is given directly at each entry, but there is no "[1]" in the text. So when you don't switch to the "footnote" syntax, either add it somewhere in the text or remove the entry.
Link in references are no links
The title says it all, but to be sure, here (also) a picture of the current output
(Remaining) markdownlint (VS Code) issues
MD001/heading-increment
Please check if the number of
#is really correct.Catalyst.jl/docs/src/inverse_problems/global_sensitivity_analysis.md
Line 8 in 64c117f
Catalyst.jl/docs/src/model_creation/dsl_basics.md
Line 11 in 64c117f
Catalyst.jl/docs/src/model_simulation/simulation_introduction.md
Line 6 in 64c117f
Catalyst.jl/docs/src/index.md
Line 20 in 64c117f
Catalyst.jl/docs/src/index.md
Line 132 in 64c117f
Catalyst.jl/docs/src/v14_migration_guide.md
Line 186 in 64c117f
(and the following two headings.)
MD025/single-title/single-h1
Catalyst.jl/docs/src/network_analysis/odes.md
Line 209 in 64c117f
MD029/ol-prefix
Catalyst.jl/docs/src/inverse_problems/petab_ode_param_fitting.md
Lines 76 to 84 in 64c117f
shows as
and correspondingly for
Catalyst.jl/docs/src/inverse_problems/petab_ode_param_fitting.md
Lines 426 to 434 in 64c117f
According to the "Markdown Lists" section in the Julia manual starting with another number than 1 should work, shouldn't it?
MD045/no-alt-text
The heading says it all :) Here are the instances
Catalyst.jl/docs/src/spatial_modelling/lattice_reaction_systems.md
Line 65 in 64c117f
Catalyst.jl/docs/src/spatial_modelling/lattice_simulation_plotting.md
Line 49 in 64c117f
Catalyst.jl/docs/src/spatial_modelling/lattice_simulation_plotting.md
Line 91 in 64c117f
(Perhaps you could also add a blank line at the end (if it is missing).)
MD059/descriptive-link-text
There are a lot of "[here]" links that should be replaced ... I don't give an example here, because one can simply search for e.g. "[here](" to find them all.