-GillesPy2 is a Python 3 package for stochastic simulation of biochemical systems. It offers an object-oriented approach for creating mathematical models of biological systems, as well as a variety of methods for performing time simulation of those models. The methods include the [Gillespie direct method (SSA)](https://en.wikipedia.org/wiki/Gillespie_algorithm), several variant stochastic simulation methods including [tau-leaping](https://en.wikipedia.org/wiki/Tau-leaping), and numerical integration of ODEs. The solvers support a variety of user environments, with optimized code for C++, [Cython](https://cython.org), and [NumPy](https://numpy.org). GillesPy2 also supports [SBML](https://en.wikipedia.org/wiki/SBML).
+GillesPy2 is a Python 3 package for stochastic simulation of biochemical systems. It offers an object-oriented approach for creating mathematical models of biological systems, as well as a variety of methods for performing time simulation of those models. The methods include the [Gillespie direct method (SSA)](https://en.wikipedia.org/wiki/Gillespie_algorithm), several variant stochastic simulation methods including [tau-Leaping](https://en.wikipedia.org/wiki/Tau-leaping), and numerical integration of ODEs. The solvers support a variety of user environments, with optimized code for C++, [Cython](https://cython.org), and [NumPy](https://numpy.org). GillesPy2 also supports [SBML](https://en.wikipedia.org/wiki/SBML).
@@ -70,7 +70,7 @@ GillesPy2 provides simple object-oriented abstractions for defining a model of a
1. Create a `GillesPy2.Model` containing molecular species, parameters, and reactions (or import it from an [SBML](http://sbml.org) file)
2. Invoke the model's `.run()` method.
-The `run()` method can be customized using keyword arguments to select different solvers, random seed, data return type and more. For more detailed examples on how to use GillesPy2, please see the [Getting Started](https://github.com/StochSS/GillesPy2/tree/main/examples/StartHere.ipynb) Jupyter notebook contained in the [examples](https://github.com/StochSS/GillesPy2/tree/main/examples) subdirectory.
+The `run()` method can be customized using keyword arguments to select different solvers, random seed, data return type and more. For more detailed examples on how to use GillesPy2, please see the [Getting Started](https://github.com/StochSS/GillesPy2/tree/main/examples/Start_Here.ipynb) Jupyter notebook contained in the [examples](https://github.com/StochSS/GillesPy2/tree/main/examples) subdirectory.
### _Simple example to illustrate the use of GillesPy2_
@@ -82,43 +82,44 @@ The `run()` method can be customized using keyword arguments to select different
kd-In GillesPy2, a model is expressed as an object having the parent class `Model`. Components of the model, such as the reactions, molecular species, and characteristics such as the time span for simulation, are all defined within the subclass definition. The following Python code represents our dimerization model using GillesPy2's facility: +In GillesPy2, a model is expressed as an object. Components, such as the reactions, molecular species, and characteristics such as the time span for simulation, are all defined within the model. The following Python code represents our dimerization model using GillesPy2's facility: ```python -class Dimerization(gillespy2.Model): - def __init__(self, parameter_values=None): - # First call the gillespy2.Model initializer. - gillespy2.Model.__init__(self, name='Dimerization') - - # Define parameters for the rates of creation and dissociation. - k_c = gillespy2.Parameter(name='k_c', expression=0.005) - k_d = gillespy2.Parameter(name='k_d', expression=0.08) - self.add_parameter([k_c, k_d]) - - # Define variables for the molecular species representing M and D. - m = gillespy2.Species(name='monomer', initial_value=30) - d = gillespy2.Species(name='dimer', initial_value=0) - self.add_species([m, d]) - - # The list of reactants and products for a Reaction object are each a - # Python dictionary in which the dictionary keys are Species objects - # and the values are stoichiometries of the species in the reaction. - r_c = gillespy2.Reaction(name="r_creation", rate=k_c, reactants={m:2}, products={d:1}) - r_d = gillespy2.Reaction(name="r_dissociation", rate=k_d, reactants={d:1}, products={m:2}) - self.add_reaction([r_c, r_d]) - - # Set the timespan for the simulation. - self.timespan(numpy.linspace(0, 100, 101)) +def create_dimerization(parameter_values=None): + # First call the gillespy2.Model initializer. + model = gillespy2.model(name='Dimerization') + + # Define parameters for the rates of creation and dissociation. + k_c = gillespy2.Parameter(name='k_c', expression=0.005) + k_d = gillespy2.Parameter(name='k_d', expression=0.08) + model.add_parameter([k_c, k_d]) + + # Define variables for the molecular species representing M and D. + m = gillespy2.Species(name='monomer', initial_value=30) + d = gillespy2.Species(name='dimer', initial_value=0) + model.add_species([m, d]) + + # The list of reactants and products for a Reaction object are each a + # Python dictionary in which the dictionary keys are Species objects + # and the values are stoichiometries of the species in the reaction. + r_c = gillespy2.Reaction(name="r_creation", rate=k_c, reactants={m:2}, products={d:1}) + r_d = gillespy2.Reaction(name="r_dissociation", rate=k_d, reactants={d:1}, products={m:2}) + model.add_reaction([r_c, r_d]) + + # Set the timespan for the simulation. + tspan = gillespy2.TimeSpan.linspace(t=100, num_points=101) + model.timespan(tspan) + return model ``` -Given the class definition above, the model can be simulated by first instantiating the class object, and then invoking the `run()` method on the object. The following code will run the model 10 times to produce 10 sample trajectories: +Given the model creation function above, the model can be simulated by first instantiating the model object, and then invoking the run() method on the object. The following code will run the model 10 times to produce 10 sample trajectories: ```python -model = Dimerization() +model = create_dimerization() results = model.run(number_of_trajectories=10) ``` -The results are then stored in a class `Results` object for single trajectories, or a class `Ensemble` object for multiple trajectories. Results/Ensembles can be plotted with matplotlib using `plot()` or in plotly (offline) using `plotplotly()`. For additional plotting options such as plotting from a selection of species, or statistical plotting, please see the documentation.: +The results are then stored in a class `Results` object for single trajectory or for multiple trajectories. Results can be plotted with matplotlib using `plot()` or in plotly (offline) using `plotplotly()`. For additional plotting options such as plotting from a selection of species, or statistical plotting, please see the documentation.: ```python results.plot() diff --git a/docs/build/html/.buildinfo b/docs/build/html/.buildinfo index ff1203ab5..531de3e02 100644 --- a/docs/build/html/.buildinfo +++ b/docs/build/html/.buildinfo @@ -1,4 +1,4 @@ # Sphinx build info version 1 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. -config: 3660d62a689826af0ef6e8b2cfa373ce +config: b55ff5dc6e7452417ea83baca6ee686c tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/docs/build/html/.doctrees/classes/gillespy2.core.doctree b/docs/build/html/.doctrees/classes/gillespy2.core.doctree index 3b4d6a716..4d1e416d4 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.core.doctree and b/docs/build/html/.doctrees/classes/gillespy2.core.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.doctree b/docs/build/html/.doctrees/classes/gillespy2.doctree index f24147daf..8c2572e9e 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.doctree and b/docs/build/html/.doctrees/classes/gillespy2.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.sbml.doctree b/docs/build/html/.doctrees/classes/gillespy2.sbml.doctree index b6aa336c7..a1d5e03e9 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.sbml.doctree and b/docs/build/html/.doctrees/classes/gillespy2.sbml.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.solvers.auto.doctree b/docs/build/html/.doctrees/classes/gillespy2.solvers.auto.doctree index dec88b817..101b97b62 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.solvers.auto.doctree and b/docs/build/html/.doctrees/classes/gillespy2.solvers.auto.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.solvers.cpp.build.doctree b/docs/build/html/.doctrees/classes/gillespy2.solvers.cpp.build.doctree index d2ca8c9d9..74963c653 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.solvers.cpp.build.doctree and b/docs/build/html/.doctrees/classes/gillespy2.solvers.cpp.build.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.solvers.cpp.doctree b/docs/build/html/.doctrees/classes/gillespy2.solvers.cpp.doctree index 1f4c9fe53..3305c98ee 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.solvers.cpp.doctree and b/docs/build/html/.doctrees/classes/gillespy2.solvers.cpp.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.solvers.cython.doctree b/docs/build/html/.doctrees/classes/gillespy2.solvers.cython.doctree index 0df99d455..e3b607004 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.solvers.cython.doctree and b/docs/build/html/.doctrees/classes/gillespy2.solvers.cython.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.solvers.doctree b/docs/build/html/.doctrees/classes/gillespy2.solvers.doctree index 121ee6e47..f457e39a1 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.solvers.doctree and b/docs/build/html/.doctrees/classes/gillespy2.solvers.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.solvers.numpy.doctree b/docs/build/html/.doctrees/classes/gillespy2.solvers.numpy.doctree index 494fdd72b..ddb879dac 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.solvers.numpy.doctree and b/docs/build/html/.doctrees/classes/gillespy2.solvers.numpy.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.solvers.stochkit.doctree b/docs/build/html/.doctrees/classes/gillespy2.solvers.stochkit.doctree index da65dcc8f..9e3b4882b 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.solvers.stochkit.doctree and b/docs/build/html/.doctrees/classes/gillespy2.solvers.stochkit.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.solvers.utilities.doctree b/docs/build/html/.doctrees/classes/gillespy2.solvers.utilities.doctree index d991354fe..e54534113 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.solvers.utilities.doctree and b/docs/build/html/.doctrees/classes/gillespy2.solvers.utilities.doctree differ diff --git a/docs/build/html/.doctrees/classes/gillespy2.stochss.doctree b/docs/build/html/.doctrees/classes/gillespy2.stochss.doctree index f94a7b20b..81805821f 100644 Binary files a/docs/build/html/.doctrees/classes/gillespy2.stochss.doctree and b/docs/build/html/.doctrees/classes/gillespy2.stochss.doctree differ diff --git a/docs/build/html/.doctrees/environment.pickle b/docs/build/html/.doctrees/environment.pickle index d3b222681..a71c9c6ca 100644 Binary files a/docs/build/html/.doctrees/environment.pickle and b/docs/build/html/.doctrees/environment.pickle differ diff --git a/docs/build/html/.doctrees/getting_started/basic_usage/basic_usage.doctree b/docs/build/html/.doctrees/getting_started/basic_usage/basic_usage.doctree index f22742bcd..0b88c2114 100644 Binary files a/docs/build/html/.doctrees/getting_started/basic_usage/basic_usage.doctree and b/docs/build/html/.doctrees/getting_started/basic_usage/basic_usage.doctree differ diff --git a/docs/build/html/.doctrees/getting_started/installation/installation.doctree b/docs/build/html/.doctrees/getting_started/installation/installation.doctree index 520cfc0fb..555f2dcac 100644 Binary files a/docs/build/html/.doctrees/getting_started/installation/installation.doctree and b/docs/build/html/.doctrees/getting_started/installation/installation.doctree differ diff --git a/docs/build/html/.doctrees/index.doctree b/docs/build/html/.doctrees/index.doctree index d629dad5a..356988cce 100644 Binary files a/docs/build/html/.doctrees/index.doctree and b/docs/build/html/.doctrees/index.doctree differ diff --git a/docs/build/html/.doctrees/tutorials/tut_michaelis_menten/tut_michaelis_menten.doctree b/docs/build/html/.doctrees/tutorials/tut_michaelis_menten/tut_michaelis_menten.doctree index 7c6fb3ddd..ba09d6bfb 100644 Binary files a/docs/build/html/.doctrees/tutorials/tut_michaelis_menten/tut_michaelis_menten.doctree and b/docs/build/html/.doctrees/tutorials/tut_michaelis_menten/tut_michaelis_menten.doctree differ diff --git a/docs/build/html/.doctrees/tutorials/tut_sbml/tut_sbml.doctree b/docs/build/html/.doctrees/tutorials/tut_sbml/tut_sbml.doctree index b20c7c402..53eb4af6d 100644 Binary files a/docs/build/html/.doctrees/tutorials/tut_sbml/tut_sbml.doctree and b/docs/build/html/.doctrees/tutorials/tut_sbml/tut_sbml.doctree differ diff --git a/docs/build/html/.doctrees/tutorials/tut_toggle_switch/tut_toggle_switch.doctree b/docs/build/html/.doctrees/tutorials/tut_toggle_switch/tut_toggle_switch.doctree index aabf6c705..8ba212d0b 100644 Binary files a/docs/build/html/.doctrees/tutorials/tut_toggle_switch/tut_toggle_switch.doctree and b/docs/build/html/.doctrees/tutorials/tut_toggle_switch/tut_toggle_switch.doctree differ diff --git a/docs/build/html/_modules/gillespy2/core/assignmentrule.html b/docs/build/html/_modules/gillespy2/core/assignmentrule.html index 7773e5388..c1eaa8f31 100644 --- a/docs/build/html/_modules/gillespy2/core/assignmentrule.html +++ b/docs/build/html/_modules/gillespy2/core/assignmentrule.html @@ -5,7 +5,7 @@ -
Source code for gillespy2.core.assignmentrule
[docs] def sanitized_formula(self, species_mappings, parameter_mappings):
names = sorted(list(species_mappings.keys()) + list(parameter_mappings.keys()), key=lambda x: len(x),
diff --git a/docs/build/html/_modules/gillespy2/core/cleanup.html b/docs/build/html/_modules/gillespy2/core/cleanup.html
index a8258a27f..7ca4b33fb 100644
--- a/docs/build/html/_modules/gillespy2/core/cleanup.html
+++ b/docs/build/html/_modules/gillespy2/core/cleanup.html
@@ -5,7 +5,7 @@
- gillespy2.core.cleanup — GillesPy2 1.6.9 documentation
+ gillespy2.core.cleanup — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/core/events.html b/docs/build/html/_modules/gillespy2/core/events.html
index bf6eaee54..4c964fb1e 100644
--- a/docs/build/html/_modules/gillespy2/core/events.html
+++ b/docs/build/html/_modules/gillespy2/core/events.html
@@ -5,7 +5,7 @@
- gillespy2.core.events — GillesPy2 1.6.9 documentation
+ gillespy2.core.events — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/core/functiondefinition.html b/docs/build/html/_modules/gillespy2/core/functiondefinition.html
index c07bbf727..49715e54b 100644
--- a/docs/build/html/_modules/gillespy2/core/functiondefinition.html
+++ b/docs/build/html/_modules/gillespy2/core/functiondefinition.html
@@ -5,7 +5,7 @@
- gillespy2.core.functiondefinition — GillesPy2 1.6.9 documentation
+ gillespy2.core.functiondefinition — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/core/gillespyError.html b/docs/build/html/_modules/gillespy2/core/gillespyError.html
index 68a533a27..bcc7f6cea 100644
--- a/docs/build/html/_modules/gillespy2/core/gillespyError.html
+++ b/docs/build/html/_modules/gillespy2/core/gillespyError.html
@@ -5,7 +5,7 @@
- gillespy2.core.gillespyError — GillesPy2 1.6.9 documentation
+ gillespy2.core.gillespyError — GillesPy2 1.6.10 documentation
@@ -125,11 +125,27 @@
+
+
+
-
diff --git a/docs/build/html/_modules/gillespy2/core/gillespySolver.html b/docs/build/html/_modules/gillespy2/core/gillespySolver.html
index fb1540773..940901845 100644
--- a/docs/build/html/_modules/gillespy2/core/gillespySolver.html
+++ b/docs/build/html/_modules/gillespy2/core/gillespySolver.html
@@ -5,7 +5,7 @@
- Source code for gillespy2.core.gillespyError
passSource code for gillespy2.core.gillespySolver
[docs] def run(self, model, t=20, number_of_trajectories=1, increment=0.05, seed=None,
- debug=False, profile=False, show_labels=None, **kwargs):
+ debug=False, profile=False, **kwargs):
"""
Call out and run the solver. Collect the results.
@@ -154,9 +154,6 @@ :param debug: Set to True to provide additional debug information about the simulation.
:type debug: bool
- :param show_labels: Use names of species as index of result object rather than position numbers.
- :type show_labels: bool
-
:returns: Simulation trajectories.
"""
raise SimulationError("This abstract solver class cannot be used directly.")
@@ -202,21 +199,20 @@ tspan = TimeSpan.arange(increment)
else:
tspan = TimeSpan.arange(increment, t=t)
- self.model.timespan(tspan)
- elif not isinstance(self.model.tspan, TimeSpan) or type(self.model.tspan).__name__ != "TimeSpan":
- tspan = TimeSpan(self.model.tspan)
- self.model.timespan(tspan)
- else:
- self.model.tspan.validate()
+ self.model.timespan(tspan)
+
+
Source code for gillespy2.core.gillespySolver
Source code for gillespy2.core.gillespySolver
[docs] @classmethod
def validate_model(cls, sol_model, model):
if model is not None:
- model.resolve_parameters()
+ model.compile_prep()
if model.tspan is None:
model = copy.deepcopy(model)
model.tspan = sol_model.tspan
@@ -230,7 +226,12 @@ unsupported_features = [feature.__name__ for feature in unsupported_features]
raise ModelError(f"Could not run Model, "
f"SBML Features not supported by {cls.name}: " +
- ", ".join(unsupported_features))
+ ", ".join(unsupported_features))Source code for gillespy2.core.gillespySolver
[docs] @classmethod
+ def validate_integrator_options(cls, options: "dict[str, float]") -> "dict[str, float]":
+ return { option: value for option, value in options.items() if option in cls.get_supported_integrator_options() }
Source code for gillespy2.core.model
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
+import platform
import numpy as np
from typing import Set, Type
from collections import OrderedDict
@@ -132,11 +133,10 @@ Source code for gillespy2.core.model
from gillespy2.core.jsonify import Jsonify, TranslationTable
from gillespy2.core.results import Trajectory, Results
from gillespy2.core.gillespyError import (
- ParameterError,
ModelError,
SimulationError,
StochMLImportError,
- InvalidStochMLError
+ InvalidStochMLError,
)
try:
@@ -151,7 +151,7 @@ Source code for gillespy2.core.model
no_pretty_print = True
-[docs]def import_SBML(filename, name=None, gillespy_model=None):
+[docs]def import_SBML(filename, name=None, gillespy_model=None, report_silently_with_sbml_error=False):
"""
SBML to GillesPy model converter. NOTE: non-mass-action rates
in terms of concentrations may not be converted for population
@@ -165,6 +165,10 @@ Source code for gillespy2.core.model
:param gillespy_model: If desired, the SBML model may be added to an existing GillesPy model
:type gillespy_model: gillespy.Model
+
+ :param report_silently_with_sbml_error: SBML import will fail silently and
+ SBML errors will not output to the user.
+ :type report_silently_with_sbml_error: bool
"""
try:
@@ -172,7 +176,10 @@ Source code for gillespy2.core.model
except ImportError:
raise ImportError('SBML conversion not imported successfully')
- return convert(filename, model_name=name, gillespy_model=gillespy_model)
+ return convert(
+ filename, model_name=name, gillespy_model=gillespy_model,
+ report_silently_with_sbml_error=report_silently_with_sbml_error
+ )
[docs]def export_SBML(gillespy_model, filename=None):
@@ -218,7 +225,7 @@ Source code for gillespy2.core.model
:param name: The name of the model, or an annotation describing it.
:type name: str
-
+
:param population: The type of model being described. A discrete stochastic model is a
population model (True), a deterministic model is a concentration model
(False). Automatic conversion from population to concentration models
@@ -227,13 +234,13 @@ Source code for gillespy2.core.model
:param volume: The volume of the system matters when converting to from population to
concentration form. This will also set a parameter "vol" for use in
- custom (i.e. non-mass-action) propensity functions.
- :type volume: float
-
+ custom (i.e. non-mass-action) propensity functions.
+ :type volume: float
+
:param tspan: The timepoints at which the model should be simulated. If None, a
default timespan is added. May be set later, see Model.timespan
:type tspan: numpy ndarray
-
+
:param annotation: Option further description of model
:type annotation: str
"""
@@ -336,9 +343,149 @@ Source code for gillespy2.core.model
print_string += decorate('Function Definitions')
for fd in sorted(self.listOfFunctionDefinitions.values()):
print_string += '\n' + str(fd)
-
+ if self.tspan is not None:
+ print_string += decorate('Timespan')
+ print_string += str(self.tspan)
return print_string
+ def __getitem__(self, key):
+ if isinstance(key, str):
+ return self.get_element(key)
+ if hasattr(self.__class__, "__missing__"):
+ return self.__class__.__missing__(self, key)
+ raise KeyError(f"{key} is an invalid key.")
+
+ def _problem_with_name(self, name):
+ if name in Model.reserved_names:
+ names = Model.reserved_names
+ raise ModelError(
+ f'Name "{name}" is unavailable. It is reserved for internal GillesPy use. Reserved Names: ({names}).'
+ )
+ if name in self.listOfSpecies:
+ raise ModelError(f'Name "{name}" is unavailable. A species with that name exists.')
+ if name in self.listOfParameters:
+ raise ModelError(f'Name "{name}" is unavailable. A parameter with that name exists.')
+ if name in self.listOfReactions:
+ raise ModelError(f'Name "{name}" is unavailable. A reaction with that name exists.')
+ if name in self.listOfEvents:
+ raise ModelError(f'Name "{name}" is unavailable. An event with that name exists.')
+ if name in self.listOfRateRules:
+ raise ModelError(f'Name "{name}" is unavailable. A rate rule with that name exists.')
+ if name in self.listOfAssignmentRules:
+ raise ModelError(f'Name "{name}" is unavailable. An assignment rule with that name exists.')
+ if name in self.listOfFunctionDefinitions:
+ raise ModelError(f'Name "{name}" is unavailable. A function definition with that name exists.')
+ if name.isdigit():
+ raise ModelError(f'Name "{name}" is unavailable. Names must not be numeric strings.')
+ for special_character in Model.special_characters:
+ if special_character in name:
+ chars = Model.special_characters
+ raise ModelError(
+ f'Name "{name}" is unavailable. Names must not contain special characters: {chars}.'
+ )
+
+ def _resolve_event(self, event):
+ def validate(event):
+ from gillespy2.core.gillespyError import EventError
+ if event.trigger is None or not hasattr(event.trigger, 'expression'):
+ raise EventError('An Event must contain a valid trigger.')
+ try:
+ validate(event)
+
+ # Confirm that the variable in the event assignments are part of the model.
+ for assign in event.assignments:
+ name = assign.variable if isinstance(assign.variable, str) else assign.variable.name
+ assign.variable = self.get_element(name)
+ except ModelError as err:
+ raise ModelError(
+ f"Could not add/resolve event: {event.name}, Reason given: {err}"
+ ) from err
+
+ def _resolve_all_events(self):
+ for _, event in self.listOfEvents.items():
+ self._resolve_event(event)
+
+ def _resolve_parameter(self, parameter):
+ try:
+ parameter.validate()
+
+ # Calculate the parameters value.
+ self.update_namespace()
+ parameter._evaluate(self.namespace)
+ except ModelError as err:
+ raise ModelError(f"Could not add/resolve parameter: {parameter.name}, Reason given: {err}") from err
+
+ def _resolve_all_parameters(self):
+ for _, parameter in self.listOfParameters.items():
+ self._resolve_parameter(parameter)
+
+ def _resolve_rule(self, rule):
+ def validate(rule):
+ from gillespy2.core.gillespyError import RateRuleError, AssignmentRuleError
+ errors = {"RateRule": RateRuleError, "AssignmentRule": AssignmentRuleError}
+ error_class = errors[type(rule).__name__]
+ if rule.variable == None:
+ raise error_class('A GillesPy2 Rate/Assignment Rule must be associated with a valid variable')
+ if rule.formula == '':
+ raise error_class('Invalid Rate/Assignment Rule. Expression must be a non-empty string value')
+ try:
+ validate(rule)
+
+ # Confirm that the variable is part of the model.
+ name = rule.variable if isinstance(rule.variable, str) else rule.variable.name
+ rule.variable = self.get_element(name)
+ except ModelError as err:
+ raise ModelError(
+ f"Could not add/resolve rate_rule: {rule.name}, Reason given: {err}"
+ ) from err
+
+ def _resolve_all_rate_rules(self):
+ for _, rate_rule in self.listOfRateRules.items():
+ self._resolve_rule(rate_rule)
+
+ def _resolve_all_assignment_rules(self):
+ for _, assign_rule in self.listOfAssignmentRules.items():
+ self._resolve_rule(assign_rule)
+
+ def _resolve_reaction(self, reaction):
+ try:
+ reaction.validate()
+
+ # If the rate parameter exists in the reaction, confirm that it is a part of the model
+ if reaction.marate is not None:
+ name = reaction.marate if isinstance(reaction.marate, str) else reaction.marate.name
+ reaction.marate = self.get_parameter(name)
+
+ # Confirm that all species in reactants are part of the model
+ for species in list(reaction.reactants.keys()):
+ stoichiometry = reaction.reactants[species]
+ name = species if isinstance(species, str) else species.name
+ stoich_spec = self.get_species(name)
+ if stoich_spec not in reaction.reactants:
+ reaction.reactants[stoich_spec] = stoichiometry
+ del reaction.reactants[species]
+
+ # Confirm that all species in products are part of the model
+ for species in list(reaction.products.keys()):
+ stoichiometry = reaction.products[species]
+ name = species if isinstance(species, str) else species.name
+ stoich_spec = self.get_species(name)
+ if stoich_spec not in reaction.products:
+ reaction.products[stoich_spec] = stoichiometry
+ del reaction.products[species]
+ except ModelError as err:
+ raise ModelError(f"Could not add/resolve reaction: {reaction.name}, Reason given: {err}") from err
+
+ def _resolve_all_reactions(self):
+ for _, reaction in self.listOfReactions.items():
+ self._resolve_reaction(reaction)
+
+[docs] def update_namespace(self):
+ """ Create a dict with flattened parameter and species objects. """
+ self.namespace = OrderedDict([])
+ for param in self.listOfParameters:
+ self.namespace[param] = self.listOfParameters[param].value
+
[docs] def add(self, components):
"""
Adds a component, or list of components to the model. If a list is provided, Species
@@ -347,11 +494,11 @@ Source code for gillespy2.core.model
:param components: The component or list of components to be added the the model.
:type components: Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, \
- FunctionDefinitions, and TimeSpan or list
+ FunctionDefinitions, TimeSpan, or list
:returns: The components that were added to the model.
:rtype: Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, \
- FunctionDefinitions, and TimeSpan or list
+ FunctionDefinitions, TimeSpan, or list
:raises ModelError: Component is invalid.
"""
@@ -388,130 +535,83 @@ Source code for gillespy2.core.model
raise ModelError(f"Unsupported component: {type(components)} is not a valid component.")
return components
-[docs] def make_translation_table(self):
- from collections import ChainMap
-
- species = self.listOfSpecies.values()
- reactions = self.listOfReactions.values()
- parameters = self.listOfParameters.values()
- assignments = self.listOfAssignmentRules.values()
- rates = self.listOfRateRules.values()
- events = self.listOfEvents.values()
- functions = self.listOfFunctionDefinitions.values()
-
- # A translation table is used to anonymize user-defined variable names and formulas into generic counterparts.
- translation_table = dict(ChainMap(
-
- # Build translation mappings for user-defined variable names.
- dict({ self.name: "Model" }),
- dict(zip((str(x.name) for x in species), (f"S_{x + 100}" for x in range(0, len(species))))),
- dict(zip((str(x.name) for x in reactions), (f"R_{x + 100}" for x in range(0, len(reactions))))),
- dict(zip((str(x.name) for x in parameters), (f"P_{x + 100}" for x in range(0, len(parameters))))),
- dict(zip((str(x.name) for x in assignments), (f"AR_{x + 100}" for x in range(0, len(assignments))))),
- dict(zip((str(x.name) for x in rates), (f"RR_{x + 100}" for x in range(0, len(rates))))),
- dict(zip((str(x.name) for x in events), (f"E_{x + 100}" for x in range(0, len(events))))),
- dict(zip((str(x.name) for x in functions), (f"F_{x + 100}" for x in range(0, len(functions))))),
- ))
-
- return TranslationTable(to_anon=translation_table)
-
-[docs] def serialize(self):
- """ Serializes the Model object to valid StochML. """
- self.resolve_parameters()
- doc = StochMLDocument().from_model(self)
- return doc.to_string()
+[docs] def get_element(self, name):
+ """
+ Get a model element specified by name.
-[docs] def update_namespace(self):
- """ Create a dict with flattened parameter and species objects. """
- self.namespace = OrderedDict([])
- for param in self.listOfParameters:
- self.namespace[param] = self.listOfParameters[param].value
+ :param name: Name of the element to be returned.
+ :type name: str
-[docs] def sanitized_species_names(self):
- """
- Generate a dictionary mapping user chosen species names to simplified formats which will be used
- later on by GillesPySolvers evaluating reaction propensity functions.
+ :returns: The specified gillespy2.Model element.
+ :rtype: Species, Parameters, Reactions, Events, RateRules, AssignmentRules, \
+ FunctionDefinitions, or TimeSpan
- :returns: the dictionary mapping user species names to their internal GillesPy notation.
+ :raises ModelError: If the element is not part of the model.
"""
- species_name_mapping = OrderedDict([])
- for i, name in enumerate(self.listOfSpecies.keys()):
- species_name_mapping[name] = 'S[{}]'.format(i)
- return species_name_mapping
-
-[docs] def problem_with_name(self, name):
- if name in Model.reserved_names:
- raise ModelError(
- 'Name "{}" is unavailable. It is reserved for internal GillesPy use. Reserved Names: ({}).'.format(name,
- Model.reserved_names))
+ if name in ("tspan", "timespan"):
+ return self.tspan
if name in self.listOfSpecies:
- raise ModelError('Name "{}" is unavailable. A species with that name exists.'.format(name))
+ return self.get_species(name)
if name in self.listOfParameters:
- raise ModelError('Name "{}" is unavailable. A parameter with that name exists.'.format(name))
+ return self.get_parameter(name)
if name in self.listOfReactions:
- raise ModelError('Name "{}" is unavailable. A reaction with that name exists.'.format(name))
- if name in self.listOfEvents:
- raise ModelError('Name "{}" is unavailable. An event with that name exists.'.format(name))
+ return self.get_reaction(name)
if name in self.listOfRateRules:
- raise ModelError('Name "{}" is unavailable. A rate rule with that name exists.'.format(name))
+ return self.get_rate_rule(name)
if name in self.listOfAssignmentRules:
- raise ModelError('Name "{}" is unavailable. An assignment rule with that name exists.'.format(name))
+ return self.get_assignment_rule(name)
+ if name in self.listOfEvents:
+ return self.get_event(name)
if name in self.listOfFunctionDefinitions:
- raise ModelError('Name "{}" is unavailable. A function definition with that name exists.'.format(name))
- if name.isdigit():
- raise ModelError('Name "{}" is unavailable. Names must not be numeric strings.'.format(name))
- for special_character in Model.special_characters:
- if special_character in name:
- raise ModelError(
- 'Name "{}" is unavailable. Names must not contain special characters: {}.'.format(name,
- Model.special_characters))
+ return self.get_function_definition(name)
+ raise ModelError(f"{self.name} does not contain an element named {name}.")
-[docs] def get_species(self, s_name):
+[docs] def add_species(self, species):
"""
- Returns a species object by name.
+ Adds a species, or list of species to the model.
- :param s_name: Name of the species object to be returned:
- :type s_name: str
- """
- return self.listOfSpecies[s_name]
+ :param species: The species or list of species to be added to the model object
+ :type species: gillespy2.Species | list of gillespy2.Species
-[docs] def get_all_species(self):
- """
- :returns: A dict of all species in the model, of the form:
- {name : species object}
- """
- return self.listOfSpecies
-
-[docs] def add_species(self, obj):
- """
- Adds a species, or list of species to the model.
+ :returns: The species or list of species that were added to the model.
+ :rtype: gillespy2.Species | list of gillespy2.Species
- :param obj: The species or list of species to be added to the model object
- :type obj: Species, or list of species
+ :raises ModelError: If an invalid species is provided or if Species.validate fails.
"""
-
- if isinstance(obj, list):
- for S in sorted(obj):
- self.add_species(S)
- else:
+ if isinstance(species, list):
+ for spec in sorted(species):
+ self.add_species(spec)
+ elif isinstance(species, Species) or type(species).__name__ == "Species":
try:
- self.problem_with_name(obj.name)
- self.listOfSpecies[obj.name] = obj
- self._listOfSpecies[obj.name] = 'S{}'.format(len(self._listOfSpecies))
- except Exception as e:
- raise ParameterError("Error using {} as a Species. Reason given: {}".format(obj, e))
- return obj
+ species.validate()
+ self._problem_with_name(species.name)
+ self.listOfSpecies[species.name] = species
+ self._listOfSpecies[species.name] = f'S{len(self._listOfSpecies)}'
+ except ModelError as err:
+ errmsg = f"Could not add species: {species.name}, Reason given: {err}"
+ raise ModelError(errmsg) from err
+ else:
+ errmsg = f"species must be of type Species or list of Species not {type(species)}."
+ raise ModelError(errmsg)
+ return species
[docs] def delete_species(self, name):
"""
Removes a species object by name.
- :param name: Name of the species object to be removed
+ :param name: Name of the species object to be removed.
:type name: str
+
+ :raises ModelError: If the species is not part of the model.
"""
- self.listOfSpecies.pop(name)
- if name in self._listOfSpecies:
- self._listOfSpecies.pop(name)
+ try:
+ self.listOfSpecies.pop(name)
+ if name in self._listOfSpecies:
+ self._listOfSpecies.pop(name)
+ except KeyError as err:
+ raise ModelError(
+ f"{self.name} does not contain a species named {name}."
+ ) from err
[docs] def delete_all_species(self):
"""
@@ -520,484 +620,584 @@ Source code for gillespy2.core.model
self.listOfSpecies.clear()
self._listOfSpecies.clear()
-[docs] def set_units(self, units):
+[docs] def get_species(self, name):
"""
- Sets the units of the model to either "population" or "concentration"
+ Returns a species object by name.
- :param units: Either "population" or "concentration"
- :type units: str
- """
- if units.lower() == 'concentration' or units.lower() == 'population':
- self.units = units.lower()
- else:
- raise ModelError("units must be either concentration or population (case insensitive)")
+ :param name: Name of the species object to be returned.
+ :type name: str
-[docs] def sanitized_parameter_names(self):
- """
- Generate a dictionary mapping user chosen parameter names to simplified formats which will be used
- later on by GillesPySolvers evaluating reaction propensity functions.
+ :returns: The specified species object.
+ :rtype: gillespy2.Species
- :returns: the dictionary mapping user parameter names to their internal GillesPy notation.
+ :raises ModelError: If the species is not part of the model.
"""
- parameter_name_mapping = OrderedDict()
- parameter_name_mapping['vol'] = 'V'
- for i, name in enumerate(self.listOfParameters.keys()):
- if name not in parameter_name_mapping:
- parameter_name_mapping[name] = 'P{}'.format(i)
- return parameter_name_mapping
+ if name not in self.listOfSpecies:
+ raise ModelError(f"{self.name} does not contain a species named {name}.")
+ return self.listOfSpecies[name]
-[docs] def get_parameter(self, p_name):
+[docs] def get_all_species(self):
"""
- Returns a parameter object by name.
+ Get all of the species in the model object.
- :param p_name: Name of the parameter object to be returned
- :type p_name: str
+ :returns: A dict of all species in the model, in the form: {name : species object}.
+ :rtype: OrderedDict
"""
- try:
- return self.listOfParameters[p_name]
- except:
- raise ModelError("No parameter named " + p_name)
+ return self.listOfSpecies
-[docs] def get_all_parameters(self):
+[docs] def sanitized_species_names(self):
"""
- :returns: A dict of all parameters in the model, of the form:
- {name : parameter object}
+ Generate a dictionary mapping user chosen species names to simplified formats which will be used
+ later on by GillesPySolvers evaluating reaction propensity functions.
+
+ :returns: the dictionary mapping user species names to their internal GillesPy notation.
"""
- return self.listOfParameters
+ species_name_mapping = OrderedDict([])
+ for i, name in enumerate(self.listOfSpecies.keys()):
+ species_name_mapping[name] = 'S[{}]'.format(i)
+ return species_name_mapping
-[docs] def add_parameter(self, params):
+[docs] def add_parameter(self, parameters):
"""
Adds a parameter, or list of parameters to the model.
- :param params: The parameter or list of parameters to be added to the model object.
- :type params: Parameter, or list of parameters
+ :param parameters: The parameter or list of parameters to be added to the model object.
+ :type parameters: gillespy2.Parameter | list of gillespy2.Parameter
+
+ :returns: A parameter or list of Parameters that were added to the model.
+ :rtype: gillespy2.Parameter | list of gillespy2.Parameter
+
+ :raises ModelError: If an invalid parameter is provided or if Parameter.validate fails.
"""
- if isinstance(params, list):
- for p in sorted(params):
- self.add_parameter(p)
+ if isinstance(parameters, list):
+ for param in sorted(parameters):
+ self.add_parameter(param)
+ elif isinstance(parameters, Parameter) or type(parameters).__name__ == 'Parameter':
+ self._problem_with_name(parameters.name)
+ self._resolve_parameter(parameters)
+ self.listOfParameters[parameters.name] = parameters
+ self._listOfParameters[parameters.name] = f'P{len(self._listOfParameters)}'
else:
- if isinstance(params, Parameter) or type(params).__name__ == 'Parameter':
- self.problem_with_name(params.name)
- self.update_namespace()
- params._evaluate(self.namespace)
- self.listOfParameters[params.name] = params
- self._listOfParameters[params.name] = 'P{}'.format(len(self._listOfParameters))
- else:
- raise ParameterError("Parameter {} must be of type {}, it is of type {}".format(params, str(type(Parameter)), str(params) ))
- return params
+ errmsg = f"parameters must be of type Parameter or list of Parameter not {type(parameters)}."
+ raise ModelError(errmsg)
+ return parameters
[docs] def delete_parameter(self, name):
"""
Removes a parameter object by name.
- :param name: Name of the parameter object to be removed
+ :param name: Name of the parameter object to be removed.
:type name: str
+
+ :raises ModelError: If the parameter is not part of the model.
"""
- self.listOfParameters.pop(name)
- if name in self._listOfParameters:
- self._listOfParameters.pop(name)
+ try:
+ self.listOfParameters.pop(name)
+ if name in self._listOfParameters:
+ self._listOfParameters.pop(name)
+ except KeyError as err:
+ raise ModelError(
+ f"{self.name} does not contain a parameter named {name}."
+ ) from err
-[docs] def set_parameter(self, p_name, expression):
+[docs] def delete_all_parameters(self):
+ """
+ Removes all parameters from model object.
+ """
+ self.listOfParameters.clear()
+ self._listOfParameters.clear()
+
+[docs] def get_parameter(self, name):
"""
- Set the value of an existing parameter "pname" to "expression".
+ Returns a parameter object by name.
- :param p_name: Name of the parameter whose value will be set.
- :type p_name: str
+ :param name: Name of the parameter object to be returned
+ :type name: str
- :param expression: String that may be executed in C, describing the value of the
- parameter. May reference other parameters by name. (e.g. "k1*4")
- :type expression: str
- """
+ :returns: The specified parameter object.
+ :rtype: gillespy2.Parameter
- p = self.listOfParameters[p_name]
- p.expression = expression
- p._evaluate()
+ :raises ModelError: If the parameter is not part of the model.
+ """
+ if name not in self.listOfParameters:
+ raise ModelError(f"{self.name} does not contain a parameter named {name}.")
+ return self.listOfParameters[name]
-[docs] def resolve_parameters(self):
- """ Internal function:
- attempt to resolve all parameter expressions to scalar floats.
- This methods must be called before exporting the model.
+[docs] def get_all_parameters(self):
+ """
+ Get all of the parameters in the model object.
+
+ :returns: A dict of all parameters in the model, in the form: {name : parameter object}
+ :rtype: OrderedDict
"""
- self.update_namespace()
- for param in self.listOfParameters:
- self.listOfParameters[param]._evaluate(self.namespace)
+ return self.listOfParameters
-[docs] def delete_all_parameters(self):
- """ Deletes all parameters from model. """
- self.listOfParameters.clear()
- self._listOfParameters.clear()
+[docs] def sanitized_parameter_names(self):
+ """
+ Generate a dictionary mapping user chosen parameter names to simplified formats which will be used
+ later on by GillesPySolvers evaluating reaction propensity functions.
-[docs] def validate_reactants_and_products(self, reactions):
- for reactant in list(reactions.reactants.keys()):
- if isinstance(reactant, str):
- if reactant not in self.listOfSpecies.keys():
- raise ModelError(
- 'reactant: {0} for reaction {1} -- not found in model.listOfSpecies'.format(reactant,
- reactions.name))
- reactions.reactants[self.listOfSpecies[reactant]] = reactions.reactants[reactant]
- del reactions.reactants[reactant]
- for product in list(reactions.products.keys()):
- if isinstance(product, str):
- if product not in self.listOfSpecies.keys():
- raise ModelError('product: {0} for reaction {1} -- not found in model.listOfSpecies'.format(product,
- reactions.name))
- reactions.products[self.listOfSpecies[product]] = reactions.products[product]
- del reactions.products[product]
+ :returns: the dictionary mapping user parameter names to their internal GillesPy notation.
+ """
+ parameter_name_mapping = OrderedDict()
+ parameter_name_mapping['vol'] = 'V'
+ for i, name in enumerate(self.listOfParameters.keys()):
+ if name not in parameter_name_mapping:
+ parameter_name_mapping[name] = 'P{}'.format(i)
+ return parameter_name_mapping
[docs] def add_reaction(self, reactions):
"""
Adds a reaction, or list of reactions to the model.
- :param reactions: The reaction or list of reaction objects to be added to the model
- object.
- :type reactions: Reaction, or list of Reactions
- """
+ :param reactions: The reaction or list of reactions to be added to the model object
+ :type reactions: gillespy2.Reaction | list of gillespy2.Reaction
- # TODO, make sure that you cannot overwrite an existing reaction
+ :returns: The reaction or list of reactions that were added to the model.
+ :rtype: gillespy2.Reaction | list of gillespy2.Reaction
+
+ :raises ModelError: If an invalid reaction is provided or if Reaction.validate fails.
+ """
if isinstance(reactions, list):
- for r in sorted(reactions):
- self.add_reaction(r)
+ for reaction in sorted(reactions):
+ self.add_reaction(reaction)
+ elif isinstance(reactions, Reaction) or type(reactions).__name__ == "Reaction":
+ self._problem_with_name(reactions.name)
+ self._resolve_reaction(reactions)
+ self.listOfReactions[reactions.name] = reactions
+ # Build Sanitized reaction as well
+ sanitized_reaction = reactions._create_sanitized_reaction(
+ len(self.listOfReactions), self._listOfSpecies, self._listOfParameters
+ )
+ self._listOfReactions[reactions.name] = sanitized_reaction
else:
- try:
- self.problem_with_name(reactions.name)
- reactions.verify()
- self.validate_reactants_and_products(reactions)
- if reactions.name is None or reactions.name == '':
- i = 0
- while True:
- if 'reaction{}'.format(i) in self.listOfReactions:
- i += 1
- else:
- self.listOfReactions['reaction{}'.format(i)] = reactions
- break
- else:
- if reactions.name in self.listOfReactions:
- raise ModelError("Duplicate name of reaction: {0}".format(reactions.name))
- self.listOfReactions[reactions.name] = reactions
- # Build Sanitized reaction as well
- sanitized_reaction = Reaction(name='R{}'.format(len(self._listOfReactions)))
- sanitized_reaction.reactants = {self._listOfSpecies[species.name]: reactions.reactants[species] for
- species in reactions.reactants}
- sanitized_reaction.products = {self._listOfSpecies[species.name]: reactions.products[species] for
- species in reactions.products}
- sanitized_reaction.propensity_function = reactions.sanitized_propensity_function(self._listOfSpecies,
- self._listOfParameters)
- self._listOfReactions[reactions.name] = sanitized_reaction
- except Exception as e:
- raise ParameterError("Error using {} as a Reaction. Reason given: {}".format(reactions, e))
+ errmsg = f"reactions must be of type Reaction or list of Reaction not {type(reactions)}."
+ raise ModelError(errmsg)
return reactions
-[docs] def add_rate_rule(self, rate_rules):
+[docs] def delete_reaction(self, name):
"""
- Adds a rate rule, or list of rate rules to the model.
+ Removes a reaction object by name.
- :param rate_rules: The rate rule or list of rate rule objects to be added to the model object.
- :type rate_rules: RateRule, or list of RateRules
+ :param name: Name of the reaction object to be removed.
+ :type name: str
+
+ :raises ModelError: If the reaction is not part of the model.
"""
- if isinstance(rate_rules, list):
- for rr in sorted(rate_rules):
- self.add_rate_rule(rr)
- else:
- try:
- self.problem_with_name(rate_rules.name)
- if len(self.listOfAssignmentRules) != 0:
- for i in self.listOfAssignmentRules.values():
- if rate_rules.variable == i.variable:
- raise ModelError("Duplicate variable in rate_rules AND assignment_rules: {0}".
- format(rate_rules.variable))
- for i in self.listOfRateRules.values():
- if rate_rules.variable == i.variable:
- raise ModelError("Duplicate variable in rate_rules: {0}".format(rate_rules.variable))
- if rate_rules.name in self.listOfRateRules:
- raise ModelError("Duplicate name of rate_rule: {0}".format(rate_rules.name))
- if rate_rules.formula == '':
- raise ModelError('Invalid Rate Rule. Expression must be a non-empty string value')
- if rate_rules.variable == None:
- raise ModelError('A GillesPy2 Rate Rule must be associated with a valid variable')
- if isinstance(rate_rules.variable, str):
- v = rate_rules.variable
- if v not in self.listOfSpecies and v not in self.listOfParameters:
- raise ModelError(
- 'Invalid variable entered for Rate Rule: {}'.format(rate_rules.name))
-
- self.listOfRateRules[rate_rules.name] = rate_rules
- sanitized_rate_rule = RateRule(name='RR{}'.format(len(self._listOfRateRules)))
- sanitized_rate_rule.formula = rate_rules.sanitized_formula(self._listOfSpecies,
- self._listOfParameters)
- self._listOfRateRules[rate_rules.name] = sanitized_rate_rule
- except Exception as e:
- raise ParameterError("Error using {} as a Rate Rule. Reason given: {}".format(rate_rules, e))
- return rate_rules
+ try:
+ self.listOfReactions.pop(name)
+ if name in self._listOfReactions:
+ self._listOfReactions.pop(name)
+ except KeyError as err:
+ raise ModelError(
+ f"{self.name} does not contain a reaction named {name}."
+ ) from err
-[docs] def add_event(self, event):
+[docs] def delete_all_reactions(self):
"""
- Adds an event, or list of events to the model.
-
- :param event: The event or list of event objects to be added to the model object.
- :type event: Event, or list of Events
+ Removes all reactions from the model object.
"""
+ self.listOfReactions.clear()
+ self._listOfReactions.clear()
- if isinstance(event, list):
- for e in event:
- self.add_event(e)
- else:
- try:
- self.problem_with_name(event.name)
- if event.trigger is None or not hasattr(event.trigger, 'expression'):
- raise ModelError(
- 'An Event must contain a valid trigger.')
- for a in event.assignments:
- if isinstance(a.variable, str):
- a.variable = self.get_element(a.variable)
- self.listOfEvents[event.name] = event
- except Exception as e:
- raise ParameterError("Error using {} as Event. Reason given: {}".format(event, e))
- return event
-
-[docs] def add_function_definition(self, function_definitions):
+[docs] def get_reaction(self, name):
"""
- Add FunctionDefinition or list of FunctionDefinitions
+ Returns a reaction object by name.
+
+ :param name: Name of the reaction object to be returned
+ :type name: str
+
+ :returns: The specified reaction object.
+ :rtype: gillespy2.Reaction
- :param function_definitions: The FunctionDefinition, or list of FunctionDefinitions to be added to the model
- object.
- :type function_definitions: FunctionDefinition or list of FunctionDefinitions.
+ :raises ModelError: If the reaction is not part of the model.
"""
- if isinstance(function_definitions, list):
- for fd in function_definitions:
- self.add_function_definition(fd)
- else:
- try:
- self.problem_with_name(function_definitions.name)
- self.listOfFunctionDefinitions[function_definitions.name] = function_definitions
- except Exception as e:
- raise ParameterError(
- "Error using {} as a Function Definition. Reason given: {}".format(function_definitions, e))
+ if name not in self.listOfReactions:
+ raise ModelError(f"{self.name} does not contain a reaction named {name}.")
+ return self.listOfReactions[name]
-[docs] def add_assignment_rule(self, assignment_rules):
+[docs] def get_all_reactions(self):
"""
- Add AssignmentRule or list of AssignmentRules to the model object.
-
- :param assignment_rules: The AssignmentRule or list of AssignmentRules to be added to the model object.
- :type assignment_rules: AssignmentRule or list of AssignmentRules
+ Get all of the reactions in the model object.
+
+ :returns: A dict of all reactions in the model, in the form: {name : reaction object}.
+ :rtype: OrderedDict
"""
- if isinstance(assignment_rules, list):
- for ar in assignment_rules:
- self.add_assignment_rule(ar)
- else:
- try:
- self.problem_with_name(assignment_rules.name)
- if len(self.listOfRateRules) != 0:
- for i in self.listOfRateRules.values():
- if assignment_rules.variable == i.variable:
- raise ModelError("Duplicate variable in rate_rules AND assignment_rules: {0}".
- format(assignment_rules.variable))
- for i in self.listOfAssignmentRules.values():
- if assignment_rules.variable == i.variable:
- raise ModelError("Duplicate variable in assignment_rules: {0}"
- .format(assignment_rules.variable))
- if assignment_rules.name in self.listOfAssignmentRules:
- raise ModelError("Duplicate name in assignment_rules: {0}".format(assignment_rules.name))
- if assignment_rules.formula == '':
- raise ModelError('Invalid Assignment Rule. Expression must be a non-empty string value')
- if assignment_rules.variable == None:
- raise ModelError('A GillesPy2 Rate Rule must be associated with a valid variable')
-
- self.listOfAssignmentRules[assignment_rules.name] = assignment_rules
- except Exception as e:
- raise ParameterError("Error using {} as a Assignment Rule. Reason given: {}".format(assignment_rules, e))
+ return self.listOfReactions
-[docs] def timespan(self, time_span):
+[docs] def add_rate_rule(self, rate_rule):
"""
- Set the time span of simulation. StochKit does not support non-uniform
- timespans.
+ Adds a rate rule, or list of rate rules to the model.
- :param time_span: Evenly-spaced list of times at which to sample the species populations during the simulation.
- Best to use the form gillespy2.TimeSpan(np.linspace(<start time>, <end time>, <number of time-points, inclusive>))
- :type time_span: gillespy2.TimeSpan | iterator
- """
- if isinstance(time_span, TimeSpan) or type(time_span).__name__ == "TimeSpan":
- self.tspan = time_span
+ :param rate_rule: The rate rule or list of rate rules to be added to the model object.
+ :type rate_rule: gillespy2.RateRule | list of gillespy2.RateRules
+
+ :returns: The rate rule or list of rate rules that were added to the model.
+ :rtype: gillespy2.RateRule | list of gillespy2.RateRule
+
+ :raises ModelError: If an invalid rate rule is provided or if rate rule validation fails.
+ """
+ if isinstance(rate_rule, list):
+ for r_rule in sorted(rate_rule):
+ self.add_rate_rule(r_rule)
+ elif isinstance(rate_rule, RateRule) or type(rate_rule).__name__ == "RateRule":
+ self._problem_with_name(rate_rule.name)
+ ar_vars = [a_rule.variable for a_rule in self.listOfAssignmentRules.values()]
+ rr_vars = [r_rule.variable for r_rule in self.listOfRateRules.values()]
+ if rate_rule.variable in ar_vars:
+ raise ModelError(
+ f"Duplicate variable in rate_rules AND assignment_rules: {rate_rule.variable}."
+ )
+ elif rate_rule.variable in rr_vars:
+ raise ModelError(f"Duplicate variable in rate_rules: {rate_rule.variable}.")
+ self._resolve_rule(rate_rule)
+ self.listOfRateRules[rate_rule.name] = rate_rule
+ # Build the sanitized rate rule
+ sanitized_rate_rule = RateRule(name=f'RR{len(self._listOfRateRules)}')
+ sanitized_rate_rule.formula = rate_rule.sanitized_formula(
+ self._listOfSpecies, self._listOfParameters
+ )
+ self._listOfRateRules[rate_rule.name] = sanitized_rate_rule
else:
- self.tspan = TimeSpan(time_span)
+ errmsg = f"rate_rule must be of type RateRule or list of RateRules not {type(rate_rule)}."
+ raise ModelError(errmsg)
+ return rate_rule
-[docs] def get_reaction(self, rname):
+[docs] def delete_rate_rule(self, name):
"""
- :param rname: name of reaction to return
- :returns: Reaction object
+ Removes rate rule object by name.
+
+ :param name: Name of the rate rule to be removed.
+ :type name: str
+
+ :raises ModelError: If the rate rule is not part of the model.
"""
- return self.listOfReactions[rname]
+ try:
+ self.listOfRateRules.pop(name)
+ if name in self._listOfRateRules:
+ self._listOfRateRules.pop(name)
+ except KeyError as err:
+ raise ModelError(
+ f"{self.name} does not contain a rate rule named {name}."
+ ) from err
-[docs] def get_all_reactions(self):
+[docs] def delete_all_rate_rules(self):
"""
- :returns: dict of all Reaction objects
+ Removes all rate rules from the model object.
"""
- return self.listOfReactions
+ self.listOfRateRules.clear()
+ self._listOfRateRules.clear()
-[docs] def delete_reaction(self, name):
+[docs] def get_rate_rule(self, name):
"""
- Removes a reaction object by name.
+ Returns a rate rule object by name.
- :param name: Name of Reaction to be removed,
+ :param name: Name of the rate rule object to be returned.
:type name: str
- """
- self.listOfReactions.pop(name)
- if name in self._listOfReactions:
- self._listOfReactions.pop(name)
-[docs] def delete_all_reactions(self):
- """
- Clears all reactions in model
+ :returns: The specified rate rule object.
+ :rtype: gillespy2.RateRule
+
+ :raises ModelError: If the rate rule is not part of the model.
"""
- self.listOfReactions.clear()
- self._listOfReactions.clear()
+ if name not in self.listOfRateRules:
+ raise ModelError(f"{self.name} does not contain a rate rule named {name}.")
+ return self.listOfRateRules[name]
-[docs] def get_event(self, ename):
+[docs] def get_all_rate_rules(self):
"""
- :param ename: Name of Event to get
- :returns: Event object
+ Get all of the rate rules in the model object.
+
+ :returns: A dict of all rate rules in the model, in the form: {name : rate rule object}.
+ :rtype: OrderedDict
"""
- return self.listOfEvents[ename]
+ return self.listOfRateRules
-[docs] def get_all_events(self):
+[docs] def add_assignment_rule(self, assignment_rule):
"""
- :returns: dict of all Event objects
+ Add an assignment rule, or list of assignment rules to the model.
+
+ :param assignment_rules: The assignment rule or list of assignment rules to be added to the model object.
+ :type assignment_rules: gillespy2.AssignmentRule or list of gillespy2.AssignmentRules
+
+ :returns: The assignment rule or list of assignment rules that were added to the model.
+ :rtype: gillespy2.AssignmentRule | list of gillespy2.AssignmentRule
+
+ :raises ModelError: If an invalid assignment rule is provided or if assignment rule validation fails.
"""
- return self.listOfEvents
+ if isinstance(assignment_rule, list):
+ for a_rule in assignment_rule:
+ self.add_assignment_rule(a_rule)
+ elif isinstance(assignment_rule, AssignmentRule) or type(assignment_rule).__name__ == "AssignmentRule":
+ self._problem_with_name(assignment_rule.name)
+ ar_vars = [a_rule.variable for a_rule in self.listOfAssignmentRules.values()]
+ rr_vars = [r_rule.variable for r_rule in self.listOfRateRules.values()]
+ if assignment_rule.variable in rr_vars:
+ raise ModelError(
+ f"Duplicate variable in rate_rules AND assignment_rules: {assignment_rule.variable}."
+ )
+ elif assignment_rule.variable in ar_vars:
+ raise ModelError(f"Duplicate variable in assignments_rules: {assignment_rule.variable}.")
+ self._resolve_rule(assignment_rule)
+ self.listOfAssignmentRules[assignment_rule.name] = assignment_rule
+ # Build the sanitized assignment rule
+ sanitized_assignment_rule = AssignmentRule(name=f'AR{len(self._listOfAssignmentRules)}')
+ sanitized_assignment_rule.formula = assignment_rule.sanitized_formula(
+ self._listOfSpecies, self._listOfParameters
+ )
+ self._listOfAssignmentRules[assignment_rule.name] = sanitized_assignment_rule
+ else:
+ errmsg = f"assignment_rule must be of type AssignmentRule or list of AssignmentRules not {type(assignment_rule)}"
+ raise ModelError(errmsg)
+ return assignment_rule
-[docs] def delete_event(self, name):
+[docs] def delete_assignment_rule(self, name):
"""
- Removes specified Event from model
+ Removes an assignment rule object by model.
- :param name: Name of Event to be removed.
+ :param name: Name of the assignment rule object to be removed.
:type name: str
- """
- self.listOfEvents.pop(name)
- if name in self._listOfEvents:
- self._listOfEvents.pop(name)
-[docs] def delete_all_events(self):
- """
- Clears models events
+ :raises ModelError: If the assignment rule is not part of the model.
"""
- self.listOfEvents.clear()
- self._listOfEvents.clear()
+ try:
+ self.listOfAssignmentRules.pop(name)
+ if name in self._listOfAssignmentRules:
+ self._listOfAssignmentRules.pop(name)
+ except KeyError as err:
+ raise ModelError(
+ f"{self.name} does not contain an assignment rule named {name}."
+ ) from err
-[docs] def get_rate_rule(self, rname):
+[docs] def delete_all_assignment_rules(self):
"""
- :param rname: Name of Rate Rule to get
- :returns: RateRule object
+ Removes all assignment rules from the model object.
"""
- return self.listOfRateRules[rname]
+ self.listOfAssignmentRules.clear()
+ self._listOfAssignmentRules.clear()
-[docs] def get_all_rate_rules(self):
+[docs] def get_assignment_rule(self, name):
"""
- :returns: dict of all Rate Rule objects
+ Returns an assignment rule object by name.
+
+ :param name: Name of the assignment rule object to be returned.
+ :type name: str
+
+ :returns: The specified assignment rule object.
+ :rtype: gillespy2.AssignmentRule
+
+ :raises ModelError: If the assignment rule is not part of the model.
"""
- return self.listOfRateRules
+ if name not in self.listOfAssignmentRules:
+ raise ModelError(f"{self.name} does not contain an assignment rule named {name}.")
+ return self.listOfAssignmentRules[name]
-[docs] def delete_rate_rule(self, name):
+[docs] def get_all_assignment_rules(self):
"""
- Removes specified Rate Rule from model
+ Get all of the assignment rules in the model object.
- :param name: Name of Rate Rule to be removed.
- :type name: str
+ :returns: A dict of all assignemt rules in the model, in the form: {name: reaction object}.
"""
- self.listOfRateRules.pop(name)
- if name in self._listOfRateRules:
- self._listOfRateRules.pop(name)
+ return self.listOfAssignmentRules
-[docs] def delete_all_rate_rules(self):
+[docs] def add_event(self, event):
"""
- Clears all of models Rate Rules
+ Adds an event, or list of events to the model.
+
+ :param event: The event or list of event to be added to the model object.
+ :type event: gillespy2.Event | list of gillespy2.Events
+
+ :returns: The event or list of events that were added to the model.
+ :rtype: gillespy2.Event | list of gillespy2.Event
+
+ :raises ModelError: If an invalid event is provided or if event validation fails.
"""
- self.listOfRateRules.clear()
- self._listOfRateRules.clear()
+ if isinstance(event, list):
+ for evnt in event:
+ self.add_event(evnt)
+ elif isinstance(event, Event) or type(event).__name__ == "Event":
+ self._problem_with_name(event.name)
+ self._resolve_event(event)
+ self.listOfEvents[event.name] = event
+ else:
+ errmsg = f"event must be of type Event or list of Events not {type(event)}"
+ raise ModelError(errmsg)
+ return event
-[docs] def get_assignment_rule(self, aname):
+[docs] def delete_event(self, name):
"""
- :param aname: Name of Assignment Rule to get
- :returns: Assignment Rule object
+ Removes an event object by name.
+
+ :param name: Name of the event object to be removed.
+ :type name: str
"""
- return self.listOfAssignmentRules[aname]
+ try:
+ self.listOfEvents.pop(name)
+ if name in self._listOfEvents:
+ self._listOfEvents.pop(name)
+ except KeyError as err:
+ raise ModelError(
+ f"{self.name} does not contain an event named {name}."
+ ) from err
-[docs] def get_all_assignment_rules(self):
+[docs] def delete_all_events(self):
"""
- :returns: dict of models Assignment Rules
+ Removes all events from the model object.
"""
- return self.listOfAssignmentRules
+ self.listOfEvents.clear()
+ self._listOfEvents.clear()
-[docs] def delete_assignment_rule(self, name):
+[docs] def get_event(self, name):
"""
- Removes an assignment rule from a model
+ Returns an event object by name.
- :param name: Name of AssignmentRule object to be removed from model.
+ :param name: Name of the event object to be returned.
:type name: str
- """
- self.listOfAssignmentRules.pop(name)
- if name in self._listOfAssignmentRules:
- self._listOfAssignmentRules.pop(name)
-[docs] def delete_all_assignment_rules(self):
- """
- Clears all assignment rules from model
+ :returns: The specified event object.
+ :rtype: gillespy2.Event
+
+ :raises ModelError: If the event is not part of the model.
"""
- self.listOfAssignmentRules.clear()
- self._listOfAssignmentRules.clear()
+ if name not in self.listOfEvents:
+ raise ModelError(f"{self.name} does not contain an event named {name}.")
+ return self.listOfEvents[name]
-[docs] def get_function_definition(self, fname):
+[docs] def get_all_events(self):
"""
- :param fname: name of Function to get
- :returns: FunctionDefinition object
+ Get all of the events in the model object.
+
+ :returns: A dict of all evetns in the model, in the form: {name : event object}
"""
- return self.listOfFunctionDefinitions[fname]
+ return self.listOfEvents
-[docs] def get_all_function_definitions(self):
+[docs] def add_function_definition(self, function_definition):
"""
- :returns: Dict of models function definitions
+ Add function definition, or list of function definitions to the model
+
+ :param function_definition: The function definition, or list of function definitions \
+ to be added to the model object.
+ :type function_definition: gillespy2.FunctionDefinition | list of gillespy2.FunctionDefinitions.
+
+ :returns: The function defintion or list of function definitions that were added to the model.
+ :rtype: gillespy2.FunctionDefinitions | list of gillespy2.FunctionDefinitions
+
+ :raises ModelError: If an invalid function definition is provided.
"""
- return self.listOfFunctionDefinitions
+ if isinstance(function_definition, list):
+ for func_def in function_definition:
+ self.add_function_definition(func_def)
+ elif isinstance(function_definition, FunctionDefinition) or \
+ type(function_definition).__name__ == "FunctionDefinition":
+ self._problem_with_name(function_definition.name)
+ self.listOfFunctionDefinitions[function_definition.name] = function_definition
+ else:
+ errmsg = f"function_definition must be of type FunctionDefinition or list of FunctionDefinitions not {type(function_definition)}"
+ raise ModelError(errmsg)
[docs] def delete_function_definition(self, name):
"""
- Removes specified Function Definition from model
+ Removes a function definition object by name.
- :param name: Name of Function Definition to be removed
+ :param name: Name of the function definition object to be removed.
:type name: str
"""
- self.listOfFunctionDefinitions.pop(name)
- if name in self._listOfFunctionDefinitions:
- self._listOfFunctionDefinitions.pop(name)
+ try:
+ self.listOfFunctionDefinitions.pop(name)
+ if name in self._listOfFunctionDefinitions:
+ self._listOfFunctionDefinitions.pop(name)
+ except KeyError as err:
+ raise ModelError(
+ f"{self.name} does not contain a function definition named {name}."
+ )
[docs] def delete_all_function_definitions(self):
"""
- Clears all Function Definitions from a model
+ Removes all function definitions from the model object.
"""
self.listOfFunctionDefinitions.clear()
self._listOfFunctionDefinitions.clear()
-[docs] def get_element(self, ename):
+[docs] def get_function_definition(self, name):
"""
- Get element specified by name.
+ Returns a function definition object by name.
- :param ename: name of element to search for
- :returns: value of element, or 'element not found'
+ :param name: Name of the function definition object to be returned.
+ :type name: str
+
+ :returns: The specified function definition object.
+ :rtype: gillespy2.FunctionDefinition
+ """
+ if name not in self.listOfFunctionDefinitions:
+ raise ModelError(f"{self.name} does not contain a function definition named {name}.")
+ return self.listOfFunctionDefinitions[name]
+
+[docs] def get_all_function_definitions(self):
+ """
+ Get all of the function definitions in the model object.
+
+ :returns: A dict of all function definitions in the model, in the form {name : function definition object}.
+ :rtype: OrderedDict
"""
- if ename in self.listOfReactions:
- return self.get_reaction(ename)
- if ename in self.listOfSpecies:
- return self.get_species(ename)
- if ename in self.listOfParameters:
- return self.get_parameter(ename)
- if ename in self.listOfEvents:
- return self.get_event(ename)
- if ename in self.listOfRateRules:
- return self.get_rate_rule(ename)
- if ename in self.listOfAssignmentRules:
- return self.get_assignment_rule(ename)
- if ename in self.listOfFunctionDefinitions:
- return self.get_function_definition(ename)
- raise ModelError(f"model.get_element(): element={ename} not found")
+ return self.listOfFunctionDefinitions
+
+[docs] def timespan(self, time_span):
+ """
+ Set the time span of simulation. StochKit does not support non-uniform
+ timespans.
+
+ :param time_span: Evenly-spaced list of times at which to sample the species populations during the simulation.
+ Best to use the form gillespy2.TimeSpan(np.linspace(<start time>, <end time>, <number of time-points, inclusive>))
+ :type time_span: gillespy2.TimeSpan | iterator
+ """
+ if isinstance(time_span, TimeSpan) or type(time_span).__name__ == "TimeSpan":
+ self.tspan = time_span
+ else:
+ self.tspan = TimeSpan(time_span)
+
+[docs] def make_translation_table(self):
+ from collections import ChainMap
+
+ species = self.listOfSpecies.values()
+ reactions = self.listOfReactions.values()
+ parameters = self.listOfParameters.values()
+ assignments = self.listOfAssignmentRules.values()
+ rates = self.listOfRateRules.values()
+ events = self.listOfEvents.values()
+ functions = self.listOfFunctionDefinitions.values()
+
+ # A translation table is used to anonymize user-defined variable names and formulas into generic counterparts.
+ translation_table = dict(ChainMap(
+
+ # Build translation mappings for user-defined variable names.
+ dict({ self.name: "Model" }),
+ dict(zip((str(x.name) for x in species), (f"S_{x + 100}" for x in range(0, len(species))))),
+ dict(zip((str(x.name) for x in reactions), (f"R_{x + 100}" for x in range(0, len(reactions))))),
+ dict(zip((str(x.name) for x in parameters), (f"P_{x + 100}" for x in range(0, len(parameters))))),
+ dict(zip((str(x.name) for x in assignments), (f"AR_{x + 100}" for x in range(0, len(assignments))))),
+ dict(zip((str(x.name) for x in rates), (f"RR_{x + 100}" for x in range(0, len(rates))))),
+ dict(zip((str(x.name) for x in events), (f"E_{x + 100}" for x in range(0, len(events))))),
+ dict(zip((str(x.name) for x in functions), (f"F_{x + 100}" for x in range(0, len(functions))))),
+ ))
+ return TranslationTable(to_anon=translation_table)
+
+[docs] def serialize(self):
+ """ Serializes the Model object to valid StochML. """
+ doc = StochMLDocument().from_model(self)
+ return doc.to_string()
+
+[docs] def set_units(self, units):
+ """
+ Sets the units of the model to either "population" or "concentration"
+
+ :param units: Either "population" or "concentration"
+ :type units: str
+ """
+ if units.lower() == 'concentration' or units.lower() == 'population':
+ self.units = units.lower()
+ else:
+ raise ModelError("units must be either concentration or population (case insensitive)")
[docs] def get_best_solver(self):
"""
@@ -1027,7 +1227,9 @@ Source code for gillespy2.core.model
break
from gillespy2.solvers.cpp.build.build_engine import BuildEngine
- can_use_cpp = not len(BuildEngine.get_missing_dependencies())
+ missing_deps = BuildEngine.get_missing_dependencies()
+ windows_space = platform.system() == "Windows" and " " in gillespy2.__file__
+ can_use_cpp = len(missing_deps) == 0 and not windows_space
if not can_use_cpp and not can_use_numpy:
raise ModelError('Dependency Error, cannot run model.')
@@ -1053,7 +1255,9 @@ Source code for gillespy2.core.model
"""
from gillespy2.solvers.numpy import can_use_numpy
from gillespy2.solvers.cpp.build.build_engine import BuildEngine
- can_use_cpp = not len(BuildEngine.get_missing_dependencies())
+ missing_deps = BuildEngine.get_missing_dependencies()
+ windows_space = platform.system() == "Windows" and " " in gillespy2.__file__
+ can_use_cpp = len(missing_deps) == 0 and not windows_space
chybrid_check = True
if len(self.get_all_assignment_rules()) or len(self.get_all_function_definitions()):
chybrid_check = False
@@ -1099,7 +1303,7 @@ Source code for gillespy2.core.model
else:
raise ModelError("Invalid value for the argument 'algorithm' entered. "
- "Please enter 'SSA', 'ODE', 'CLE', 'Tau-leaping', or 'Tau-Hybrid'.")
+ "Please enter 'SSA', 'ODE', 'CLE', 'Tau-Leaping', or 'Tau-Hybrid'.")
[docs] def get_model_features(self) -> "Set[Type]":
"""
@@ -1119,8 +1323,26 @@ Source code for gillespy2.core.model
features.add(gillespy2.FunctionDefinition)
return features
-[docs] def run(self, solver=None, timeout=0, t=None, increment=None, show_labels=True, algorithm=None,
- **solver_args):
+[docs] def compile_prep(self):
+ """
+ Prepare the model for export or simulation.
+ """
+ for _, species in self.listOfSpecies.items():
+ species.validate()
+ self._resolve_all_parameters()
+ self._resolve_all_reactions()
+ self._resolve_all_rate_rules()
+ self._resolve_all_assignment_rules()
+ self._resolve_all_events()
+
+ if self.tspan is not None:
+ if not isinstance(self.tspan, TimeSpan) or type(self.tspan).__name__ != "TimeSpan":
+ tspan = TimeSpan(self.tspan)
+ self.timespan(tspan)
+ else:
+ self.tspan.validate()
+
+[docs] def run(self, solver=None, timeout=0, t=None, increment=None, algorithm=None, **solver_args):
"""
Function calling simulation of the model. There are a number of
parameters to be set here.
@@ -1140,8 +1362,7 @@ Source code for gillespy2.core.model
:param algorithm: Specify algorithm ('ODE', 'Tau-Leaping', or 'SSA') for GillesPy2 to automatically pick best solver using that algorithm.
:type algorithm: str
- :returns: If show_labels is False, returns a numpy array of arrays of species population data. If show_labels is
- True,returns a Results object that inherits UserList and contains one or more Trajectory objects that
+ :returns: Returns a Results object that inherits UserList and contains one or more Trajectory objects that
inherit UserDict. Results object supports graphing and csv export.
To pause a simulation and retrieve data before the simulation, keyboard interrupt the simulation by pressing
@@ -1151,10 +1372,6 @@ Source code for gillespy2.core.model
**Pause/Resume is only supported for SINGLE TRAJECTORY simulations. T MUST BE SET OR UNEXPECTED BEHAVIOR MAY OCCUR.**
"""
- if not show_labels:
- from gillespy2.core import log
- log.warning('show_labels = False is deprecated. Future releases of GillesPy2 may not support this feature.')
-
if solver is None:
if algorithm is not None:
solver = self.get_best_solver_algo(algorithm)
@@ -1176,8 +1393,64 @@ Source code for gillespy2.core.model
except Exception as e:
raise SimulationError(
"argument 'solver={}' to run() failed. Reason Given: {}".format(solver, e)
- ) from e
+ ) from e
+
+[docs] def problem_with_name(self, *args):
+ """
+ (deprecated)
+ """
+ from gillespy2.core import log
+ log.warning(
+ """
+ Model.problem_with_name has been deprecated. Future releases of GillesPy2 may
+ not support this feature. This is an internal function and should not be used.
+ """
+ )
+ self._problem_with_name(*args)
+
+[docs] def set_parameter(self, p_name, expression):
+ """
+ Set the value of an existing parameter "pname" to "expression" (deprecated).
+ :param p_name: Name of the parameter whose value will be set.
+ :type p_name: str
+
+ :param expression: String that may be executed in C, describing the value of the
+ parameter. May reference other parameters by name. (e.g. "k1*4")
+ :type expression: str
+ """
+ from gillespy2.core import log
+ log.warning(
+ """
+ Model.set_parameter has been deprecated. Future releases of GillesPy2 may
+ not support this feature. Parameter.expression should only be set in the constructor.
+ """
+ )
+
+ parameter = self.listOfParameters[p_name]
+ parameter.expression = expression
+ self._resolve_parameter(parameter)
+
+[docs] def validate_reactants_and_products(self, reactions):
+ """
+ Internal function (deprecated):
+ Ensure that the rate and all reactants and products are present in the model
+ for the given reaction. This methods must be called before exporting the model.
+
+ :param reaction: The target reaction to resolve.
+ :type reaction: gillespy2.Reaction
+
+ :raises ModelError: If the reaction can't be resolved.
+ """
+ from gillespy2.core import log
+ log.warning(
+ """
+ Model.validate_reactants_and_products has been deprecated. Future releases of
+ GillesPy2 may not support this feature. Use Model._resolve_reaction instead.
+ """
+ )
+
+ self._resolve_reaction(reactions)
[docs]class StochMLDocument():
""" Serializiation and deserialization of a Model to/from
@@ -1219,7 +1492,9 @@ Source code for gillespy2.core.model
d = eTree.Element('Description')
- #
+ # Prepare model for export
+ model.compile_prep()
+
if model.units.lower() == "concentration":
d.set('units', model.units.lower())
@@ -1248,7 +1523,9 @@ Source code for gillespy2.core.model
params.append(md.__parameter_to_element(
model.listOfParameters[pname]))
- params.append(md.__parameter_to_element(Parameter(name='vol', expression=model.volume)))
+ vol = Parameter(name='vol', expression=model.volume)
+ vol._evaluate()
+ params.append(md.__parameter_to_element(vol))
md.document.append(params)
@@ -1368,14 +1645,13 @@ Source code for gillespy2.core.model
except:
raise InvalidStochMLError("Reaction has no name.")
- reaction = Reaction(name=name, reactants={}, products={})
-
# Type may be 'mass-action','customized'
try:
- type = reac.find('Type').text
+ r_type = reac.find('Type').text
except:
raise InvalidStochMLError("No reaction type specified.")
+ g_reactants = {}
reactants = reac.find('Reactants')
try:
for ss in reactants.iter('SpeciesReference'):
@@ -1389,13 +1665,14 @@ Source code for gillespy2.core.model
try:
# The sref list should only contain one element if
# the XML file is valid.
- reaction.reactants[sref] = stoch
+ g_reactants[sref] = stoch
except Exception as e:
StochMLImportError(e)
except:
# Yes, this is correct. 'reactants' can be None
pass
+ g_products = {}
products = reac.find('Products')
try:
for ss in products.iter('SpeciesReference'):
@@ -1405,16 +1682,15 @@ Source code for gillespy2.core.model
try:
# The sref list should only contain one element if
# the XML file is valid.
- reaction.products[sref] = stoch
+ g_products[sref] = stoch
except Exception as e:
raise StochMLImportError(e)
except:
# Yes, this is correct. 'products' can be None
pass
- if type == 'mass-action':
- reaction.massaction = True
- reaction.type = 'mass-action'
+ kwargs = {}
+ if r_type == 'mass-action':
# If it is mass-action, a parameter reference is needed.
# This has to be a reference to a species instance. We
# explicitly disallow a scalar value to be passed as the
@@ -1422,7 +1698,7 @@ Source code for gillespy2.core.model
try:
ratename = reac.find('Rate').text
try:
- reaction.marate = model.listOfParameters[ratename]
+ kwargs['rate'] = model.listOfParameters[ratename]
except KeyError as k:
# No paramter name is given. This is a valid use case
# in StochKit. We generate a name for the paramter,
@@ -1433,26 +1709,25 @@ Source code for gillespy2.core.model
p = Parameter(name=generated_rate_name,
expression=ratename)
# Try to evaluate the parameter to set its value
- p._evaluate()
model.add_parameter(p)
- reaction.marate = model.listOfParameters[
- generated_rate_name]
-
- reaction.create_mass_action()
+ kwargs['rate'] = model.listOfParameters[generated_rate_name]
except Exception as e:
raise
- elif type == 'customized':
+ elif r_type == 'customized':
try:
propfunc = reac.find('PropensityFunction').text
except Exception as e:
raise InvalidStochMLError(
"Found a customized propensity function, but no expression was given. {}".format(e))
- reaction.propensity_function = propfunc
- reaction.ode_propensity_function = propfunc
+ kwargs['propensity_function'] = propfunc
else:
raise InvalidStochMLError(
"Unsupported or no reaction type given for reaction" + name)
+ reaction = Reaction(
+ name=name, reactants=g_reactants, products=g_products, **kwargs
+ )
+
model.add_reaction(reaction)
return model
diff --git a/docs/build/html/_modules/gillespy2/core/parameter.html b/docs/build/html/_modules/gillespy2/core/parameter.html
index e9f95f206..65b524b5c 100644
--- a/docs/build/html/_modules/gillespy2/core/parameter.html
+++ b/docs/build/html/_modules/gillespy2/core/parameter.html
@@ -5,7 +5,7 @@
- gillespy2.core.parameter — GillesPy2 1.6.9 documentation
+ gillespy2.core.parameter — GillesPy2 1.6.10 documentation
@@ -145,8 +145,6 @@ Source code for gillespy2.core.parameter
self.value = None
self.name = name
- if expression is None:
- raise ParameterError("initial_value can't be None type.")
if isinstance(expression, (int, float)):
expression = str(expression)
self.expression = expression
@@ -154,7 +152,7 @@ Source code for gillespy2.core.parameter
self.validate()
def __str__(self):
- return self.name + ': ' + str(self.expression)
+ return f"{self.name}: {self.expression}"
def _evaluate(self, namespace=None):
"""
@@ -178,31 +176,9 @@ Source code for gillespy2.core.parameter
namespace = {}
self.value = float(eval(self.expression, namespace))
except Exception as err:
- raise ParameterError(f"Could not evaluate expression: {err}.") from err
-
-[docs] def set_expression(self, expression):
- """
- Sets the expression for a parameter.
-
- :raises ParameterError: expression is of invalid type. expression is set to None.
- """
- # We allow expression to be passed in as a non-string type. Invalid
- # strings will be caught below. It is perfectly fine to give a scalar
- # value as the expression. This can then be evaluated in an empty
- # namespace to the scalar value.
- from gillespy2.core import log
-
- log.warning("'Parameter.set_expression' has been deprecated, future versions of GillesPy2 will not support"
- " this function. To set expression within a parameter, use Parameter.expression = expression")
-
- if expression is None:
- raise ParameterError("initial_value can't be None type.")
- if isinstance(expression, (int, float)):
- expression = str(expression)
-
- self.validate(expression=expression, coverage="expression")
-
- self.expression = expression
+ raise ParameterError(
+ f"Could not evaluate expression: '{self.expression}'. Reason given: {err}."
+ ) from err
[docs] def sanitized_expression(self, species_mappings, parameter_mappings):
names = sorted(list(species_mappings.keys()) + list(parameter_mappings.keys()), key=lambda x: len(x),
diff --git a/docs/build/html/_modules/gillespy2/core/raterule.html b/docs/build/html/_modules/gillespy2/core/raterule.html
index 5f9bf1f7d..8cd9427f7 100644
--- a/docs/build/html/_modules/gillespy2/core/raterule.html
+++ b/docs/build/html/_modules/gillespy2/core/raterule.html
@@ -5,7 +5,7 @@
- gillespy2.core.raterule — GillesPy2 1.6.9 documentation
+ gillespy2.core.raterule — GillesPy2 1.6.10 documentation
@@ -145,7 +145,8 @@ Source code for gillespy2.core.raterule
def __str__(self):
try:
- return self.name + ': Var: ' + self.variable + ': ' + self.formula
+ var_name = self.variable if isinstance(self.variable, str) else self.variable.name
+ return f"{self.name}: Var: {var_name}: {self.formula}"
except:
return 'Rate Rule: {} contains an invalid variable or formula'.format(self.name)
diff --git a/docs/build/html/_modules/gillespy2/core/reaction.html b/docs/build/html/_modules/gillespy2/core/reaction.html
index edd25660d..686107cdf 100644
--- a/docs/build/html/_modules/gillespy2/core/reaction.html
+++ b/docs/build/html/_modules/gillespy2/core/reaction.html
@@ -5,7 +5,7 @@
- gillespy2.core.reaction — GillesPy2 1.6.9 documentation
+ gillespy2.core.reaction — GillesPy2 1.6.10 documentation
@@ -115,15 +115,17 @@ Source code for gillespy2.core.reaction
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
+import ast
+import uuid
+from json.encoder import JSONEncoder
+
+import numpy as np
from gillespy2.core.species import Species
-from json.encoder import JSONEncoder
-from gillespy2.core.sortableobject import SortableObject
-from gillespy2.core.gillespyError import *
+from gillespy2.core.parameter import Parameter
from gillespy2.core.jsonify import Jsonify
-import numpy as np
-import uuid
-import ast
+from gillespy2.core.sortableobject import SortableObject
+from gillespy2.core.gillespyError import ReactionError
[docs]class Reaction(SortableObject, Jsonify):
@@ -148,7 +150,11 @@ Source code for gillespy2.core.reaction
namespace of the reaction using C operations.
:type propensity_function: str
- :param massaction: The switch to use a mass-action reaction. If set to True, a rate value is required.
+ :param ode_propensity_function: The custom ode propensity function for the reaction. Must be evaluable in the
+ namespace of the reaction using C operations.
+ :type ode_propensity_function: str
+
+ :param massaction: (deprecated) The switch to use a mass-action reaction. If set to True, a rate value is required.
:type massaction: bool
:param rate: The rate of the mass-action reaction, take care to note the units.
@@ -169,175 +175,74 @@ Source code for gillespy2.core.reaction
model based on the order it was added. This could impact seeded simulation
results if the order of addition is not preserved.
"""
-
- def __init__(self, name="", reactants={}, products={}, propensity_function=None, massaction=False, rate=None,
- annotation=None):
- """
- Initializes the reaction using short-hand notation.
- """
-
- # Metadata
- if name in (None, ""):
- self.name = f'rxn{uuid.uuid4()}'.replace('-', '_')
- else:
- self.name = name
- self.annotation = ""
-
- # We might use this flag in the future to automatically generate
- # the propensity function if set to True.
- if propensity_function is not None:
- self.massaction = False
- self.marate = None
- else:
- self.massaction = True
-
- self.propensity_function = propensity_function
- self.ode_propensity_function = propensity_function
-
- if self.propensity_function is not None and self.massaction:
- errmsg = ("Reaction {} You cannot set the propensity type to mass-action and simultaneously set a "
- "propensity function.").format(self.name)
- raise ReactionError(errmsg)
-
+ def __init__(self, name=None, reactants=None, products=None, propensity_function=None,
+ ode_propensity_function=None, rate=None, annotation=None, massaction=None):
+ if massaction is not None:
+ from gillespy2.core import log
+ log.warning(
+ """
+ massaction has been deprecated. Future releases of GillesPy2 may not support this feature.
+ Set propensity_function for massaction=False or rate for massaction=True instead.
+ """
+ )
+
+ if name is None or name == "":
+ name = f'rxn{uuid.uuid4()}'.replace('-', '_')
+ if isinstance(propensity_function, (int, float)):
+ propensity_function = str(propensity_function)
+ if isinstance(ode_propensity_function, (int, float)):
+ ode_propensity_function = str(ode_propensity_function)
+ if isinstance(rate, (int, float)):
+ rate = str(rate)
+
+ self.name = name
self.reactants = {}
- for r in reactants:
- rtype = type(r).__name__
- if rtype == 'instance':
- self.reactants[r.name] = reactants[r]
- else:
- self.reactants[r] = reactants[r]
-
self.products = {}
- for p in products:
- rtype = type(p).__name__
- if rtype == 'instance':
- self.products[p.name] = products[p]
- else:
- self.products[p] = products[p]
-
- if self.massaction:
- self.type = "mass-action"
- if rate is None:
- self.marate = None
- else:
- rtype = type(rate).__name__
- if rtype == 'instance':
- self.marate = rate.name
+ self.marate = rate
+ self.annotation = annotation
+ self.propensity_function = propensity_function
+ self.ode_propensity_function = ode_propensity_function
+
+ self.validate(reactants=reactants, products=products)
+
+ if reactants is not None:
+ for r in reactants:
+ rtype = type(r).__name__
+ if rtype == 'Species':
+ self.reactants[r.name] = reactants[r]
else:
- self.marate = rate
- self.create_mass_action()
+ self.reactants[r] = reactants[r]
+
+ if products is not None:
+ for p in products:
+ rtype = type(p).__name__
+ if rtype == 'Species':
+ self.products[p.name] = products[p]
+ else:
+ self.products[p] = products[p]
+
+ if self.marate is not None:
+ rtype = type(self.marate).__name__
+ if rtype == 'Parameter':
+ self.marate = self.marate.name
+ self.massaction = True
+ self.type = "mass-action"
+ self._create_mass_action()
else:
+ self.massaction = False
self.type = "customized"
+ if self.propensity_function is None:
+ self.propensity_function = self.ode_propensity_function
+ if self.ode_propensity_function is None:
+ self.ode_propensity_function = self.propensity_function
+ propensity = self._create_custom_propensity(self.propensity_function)
+ self.propensity_function = propensity
+ ode_propensity = self._create_custom_propensity(self.ode_propensity_function)
+ self.ode_propensity_function = ode_propensity
- def __customPropParser():
- pow_func = ast.parse("pow", mode="eval").body
-
- class ExpressionParser(ast.NodeTransformer):
- def visit_BinOp(self, node):
- node.left = self.visit(node.left)
- node.right = self.visit(node.right)
- if isinstance(node.op, (ast.BitXor, ast.Pow)):
- # ast.Call calls defined function, args include which nodes
- # are effected by function call
- call = ast.Call(func=pow_func,
- args=[node.left, node.right],
- keywords=[])
- # Copy_location copies lineno and coloffset attributes
- # from old node to new node. ast.copy_location(new_node,old_node)
- call = ast.copy_location(call, node)
- # Return changed node
- return call
- # No modification to node, classes extending NodeTransformer methods
- # Always return node or value
- else:
- return node
-
- def visit_Name(self, node):
- # Visits Name nodes, if the name nodes "id" value is 'e', replace with numerical constant
- if node.id == 'e':
- nameToConstant = ast.copy_location(ast.Num(float(np.e), ctx=node.ctx), node)
- return nameToConstant
- return node
-
- self.verify()
- expr = self.propensity_function
- expr = expr.replace('^', '**')
- expr = ast.parse(expr, mode='eval')
- expr = ExpressionParser().visit(expr)
-
- class ToString(ast.NodeVisitor):
- substitutions = {
- "ln": "log",
- }
-
- def __init__(self):
- self.string = ''
-
- def _string_changer(self, addition):
- self.string += addition
-
- def visit_BinOp(self, node):
- self._string_changer('(')
- self.visit(node.left)
- self.visit(node.op)
- self.visit(node.right)
- self._string_changer(')')
-
- def visit_Name(self, node):
- self._string_changer(node.id)
- self.generic_visit(node)
-
- def visit_Num(self, node):
- self._string_changer(str(node.n))
- self.generic_visit(node)
-
- def visit_Call(self, node):
- func_name = ToString.substitutions.get(node.func.id) \
- if node.func.id in ToString.substitutions \
- else node.func.id
- self._string_changer(func_name + '(')
- counter = 0
- for arg in node.args:
- if counter > 0:
- self._string_changer(',')
- self.visit(arg)
- counter += 1
- self._string_changer(')')
-
- def visit_Add(self, node):
- self._string_changer('+')
- self.generic_visit(node)
-
- def visit_Div(self, node):
- self._string_changer('/')
- self.generic_visit(node)
-
- def visit_Mult(self, node):
- self._string_changer('*')
- self.generic_visit(node)
-
- def visit_UnaryOp(self, node):
- self._string_changer('(')
- self.visit_Usub(node)
- self._string_changer(')')
-
- def visit_Sub(self, node):
- self._string_changer('-')
- self.generic_visit(node)
-
- def visit_Usub(self, node):
- self._string_changer('-')
- self.generic_visit(node)
-
- newFunc = ToString()
- newFunc.visit(expr)
- return newFunc.string
-
- self.propensity_function = __customPropParser()
- self.ode_propensity_function = self.propensity_function
+ self.validate(coverage="initialized")
def __str__(self):
- self.verify()
print_string = self.name
if len(self.reactants):
print_string += '\n\tReactants'
@@ -361,19 +266,100 @@ Source code for gillespy2.core.reaction
print_string += '\n\t\t' + p + ': ' + 'INVALID - ' + str(e)
print_string += '\n\tPropensity Function: ' + self.propensity_function
return print_string
-
-[docs] def verify(self):
- """ Check if the reaction is properly formatted.
- Does nothing on sucesss, raises and error on failure."""
- if self.marate is None and self.propensity_function is None:
- raise ReactionError("You must specify either a mass-action rate or a propensity function")
- if self.marate is None and self.propensity_function is not None:
- if self.propensity_function.strip() == '':
- raise ReactionError("Propensity Function cannot be empty string.")
- if len(self.reactants) == 0 and len(self.products) == 0:
- raise ReactionError("You must have a non-zero number of reactants or products.")
-
-[docs] def create_mass_action(self):
+
+ class __ExpressionParser(ast.NodeTransformer):
+ def visit_BinOp(self, node):
+ node.left = self.visit(node.left)
+ node.right = self.visit(node.right)
+ if isinstance(node.op, (ast.BitXor, ast.Pow)):
+ # ast.Call calls defined function, args include which nodes
+ # are effected by function call
+ pow_func = ast.parse("pow", mode="eval").body
+ call = ast.Call(func=pow_func,
+ args=[node.left, node.right],
+ keywords=[])
+ # Copy_location copies lineno and coloffset attributes
+ # from old node to new node. ast.copy_location(new_node,old_node)
+ call = ast.copy_location(call, node)
+ # Return changed node
+ return call
+ # No modification to node, classes extending NodeTransformer methods
+ # Always return node or value
+ else:
+ return node
+
+ def visit_Name(self, node):
+ # Visits Name nodes, if the name nodes "id" value is 'e', replace with numerical constant
+ if node.id == 'e':
+ nameToConstant = ast.copy_location(ast.Num(float(np.e), ctx=node.ctx), node)
+ return nameToConstant
+ return node
+
+ class __ToString(ast.NodeVisitor):
+ substitutions = {
+ "ln": "log",
+ }
+
+ def __init__(self):
+ self.string = ''
+
+ def _string_changer(self, addition):
+ self.string += addition
+
+ def visit_BinOp(self, node):
+ self._string_changer('(')
+ self.visit(node.left)
+ self.visit(node.op)
+ self.visit(node.right)
+ self._string_changer(')')
+
+ def visit_Name(self, node):
+ self._string_changer(node.id)
+ self.generic_visit(node)
+
+ def visit_Num(self, node):
+ self._string_changer(str(node.n))
+ self.generic_visit(node)
+
+ def visit_Call(self, node):
+ func_name = self.substitutions.get(node.func.id) \
+ if node.func.id in self.substitutions \
+ else node.func.id
+ self._string_changer(func_name + '(')
+ counter = 0
+ for arg in node.args:
+ if counter > 0:
+ self._string_changer(',')
+ self.visit(arg)
+ counter += 1
+ self._string_changer(')')
+
+ def visit_Add(self, node):
+ self._string_changer('+')
+ self.generic_visit(node)
+
+ def visit_Div(self, node):
+ self._string_changer('/')
+ self.generic_visit(node)
+
+ def visit_Mult(self, node):
+ self._string_changer('*')
+ self.generic_visit(node)
+
+ def visit_UnaryOp(self, node):
+ self._string_changer('(')
+ self.visit_Usub(node)
+ self._string_changer(')')
+
+ def visit_Sub(self, node):
+ self._string_changer('-')
+ self.generic_visit(node)
+
+ def visit_Usub(self, node):
+ self._string_changer('-')
+ self.generic_visit(node)
+
+ def _create_mass_action(self):
"""
Initializes the mass action propensity function given
self.reactants and a single parameter value.
@@ -386,91 +372,194 @@ Source code for gillespy2.core.reaction
for r in sorted(self.reactants):
total_stoch += self.reactants[r]
if total_stoch > 2:
- raise ReactionError("Reaction: A mass-action reaction cannot involve more than two of one species or one "
- "of two species. To declare a custom propensity, replace 'rate' with "
- "'propensity_function'.")
+ raise ReactionError(
+ """
+ Reaction: A mass-action reaction cannot involve more than two of
+ one species or one of two species. To declare a custom propensity,
+ replace 'rate' with 'propensity_function'.
+ """
+ )
# Case EmptySet -> Y
- if isinstance(self.marate, str):
- propensity_function = self.marate
- ode_propensity_function = self.marate
- else:
+ if isinstance(self.marate, Parameter) or type(self.marate).__name__ == "Parameter":
propensity_function = self.marate.name
ode_propensity_function = self.marate.name
+ else:
+ if isinstance(self.marate, (int, float)):
+ self.marate = str(self.marate)
+ propensity_function = self.marate
+ ode_propensity_function = self.marate
# There are only three ways to get 'total_stoch==2':
- for r in sorted(self.reactants):
- if isinstance(r, str):
- rname = r
- else:
- rname = r.name
+ for reactant, stoichiometry in self.reactants.items():
+ if isinstance(reactant, Species) or type(reactant).__name__ == "Species":
+ reactant = reactant.name
# Case 1: 2X -> Y
- if self.reactants[r] == 2:
- propensity_function = "0.5 * {0} * {1} * ({1} - 1) / vol".format(propensity_function, rname)
- ode_propensity_function += '*' + rname + '*' + rname
+ if stoichiometry == 2:
+ propensity_function = f"0.5 * {propensity_function} * {reactant} * ({reactant} - 1) / vol"
+ ode_propensity_function += f" * {reactant} * {reactant}"
else:
# Case 3: X1, X2 -> Y;
- propensity_function += "*" + rname
- ode_propensity_function += '*' + rname
+ propensity_function += f" * {reactant}"
+ ode_propensity_function += f" * {reactant}"
# Set the volume dependency based on order.
order = len(self.reactants)
if order == 2:
- propensity_function += "/vol"
+ propensity_function += " / vol"
elif order == 0:
- propensity_function += "*vol"
+ propensity_function += " * vol"
- self.propensity_function = propensity_function
- self.ode_propensity_function = ode_propensity_function
+ self.propensity_function = self._create_custom_propensity(propensity_function=propensity_function)
+ self.ode_propensity_function = self._create_custom_propensity(propensity_function=ode_propensity_function)
+
+ def _create_custom_propensity(self, propensity_function):
+ expr = propensity_function.replace('^', '**')
+ expr = ast.parse(expr, mode='eval')
+ expr = self.__ExpressionParser().visit(expr)
+
+ newFunc = self.__ToString()
+ newFunc.visit(expr)
+ return newFunc.string
+
+ def _create_sanitized_reaction(self, n_ndx, species_mappings, parameter_mappings):
+ name = f"R{n_ndx}"
+ reactants = {species_mappings[species.name]: self.reactants[species] for species in self.reactants}
+ products = {species_mappings[species.name]: self.products[species] for species in self.products}
+ propensity_function = self.sanitized_propensity_function(species_mappings, parameter_mappings)
+ return Reaction(name=name, reactants=reactants, products=products, propensity_function=propensity_function)
+
+[docs] def addProduct(self, *args, **kwargs):
+ """
+ Add a product to this reaction (deprecated)
-[docs] def setType(self, rxntype):
+ :param species: Species object to be produced by the reaction
+ :type species: spatialpy.core.species.Species
+
+ :param stoichiometry: Stoichiometry of this product.
+ :type stoichiometry: int
+ """
+ from gillespy2.core import log
+ log.warning(
+ """
+ Reaction.addProduct has been deprecated. Future releases of GillesPy2 may
+ not support this feature. Use Reaction.add_product instead.
+ """
+ )
+
+ self.add_product(*args, **kwargs)
+
+[docs] def add_product(self, species, stoichiometry):
"""
- Sets reaction type to either "mass-action" or "customized"
+ Add a product to this reaction
- :param rxntype: Either "mass-action" or "customized"
- :type rxntype: str
+ :param species: Species object to be produced by the reaction
+ :type species: spatialpy.core.species.Species | str
+
+ :param stoichiometry: Stoichiometry of this product.
+ :type stoichiometry: int
"""
- if rxntype.lower() not in {'mass-action', 'customized'}:
- raise ReactionError("Invalid reaction type.")
- self.type = rxntype.lower()
+ name = species.name if type(species).__name__ == 'Species' else species
- self.massaction = False if self.type == 'customized' else True
+ try:
+ self.validate(products={name: stoichiometry}, coverage="products")
+ except TypeError as err:
+ raise ReactionError(f"Failed to validate product. Reason given: {err}") from err
-
+
+[docs] def addReactant(self, *args, **kwargs):
"""
- Adds a reactant to the reaction (species that is consumed)
+ Add a reactant to this reaction (deprecated)
- :param S: Reactant to add to this reaction.
- :type S: gillespy2.Species
- :param stoichiometry: The stoichiometry of the given reactant.
+ :param species: reactant Species object
+ :type species: spatialpy.core.species.Species
+
+ :param stoichiometry: Stoichiometry of this participant reactant
:type stoichiometry: int
"""
- if stoichiometry <= 0:
- raise ReactionError("Reaction Stoichiometry must be a \
- positive integer.")
- self.reactants[S.name] = stoichiometry
+ from gillespy2.core import log
+ log.warning(
+ """
+ Reaction.addReactant has been deprecated. Future releases of GillesPy2 may
+ not support this feature. Use Reaction.add_reactant instead.
+ """
+ )
+
+ self.add_reactant(*args, **kwargs)
-[docs] def addProduct(self, S, stoichiometry):
+[docs] def add_reactant(self, species, stoichiometry):
"""
- Adds a product to the reaction (species that is created)
+ Add a reactant to this reaction
- :param S: Product to add to this reaction.
- :type S: gillespy2.Species
- :param stoichiometry: The stoichiometry of the given product.
+ :param species: reactant Species object
+ :type species: spatialpy.core.species.Species
+
+ :param stoichiometry: Stoichiometry of this participant reactant
:type stoichiometry: int
"""
- self.products[S.name] = stoichiometry
+ name = species.name if type(species).__name__ == 'Species' else species
+
+ try:
+ self.validate(reactants={name: stoichiometry}, coverage="reactants")
+ except TypeError as err:
+ raise ReactionError(f"Failed to validate reactant. Reason given: {err}") from err
+
+ self.reactants[name] = stoichiometry
+ if self.massaction and self.type == "mass-action":
+ self._create_mass_action()
-
+
+[docs] def Annotate(self, *args, **kwargs):
"""
- Adds a note to the reaction
+ Add an annotation to this reaction (deprecated).
- :param annotation: An optional note about the reaction.
+ :param annotation: Annotation note to be added to reaction
:type annotation: str
"""
- self.annotation = annotation
+ from gillespy2.core import log
+ log.warning(
+ """
+ Reaction.Annotate has been deprecated. Future releases of GillesPy2 may
+ not support this feature. Use Reaction.set_annotation instead.
+ """
+ )
+
+ self.set_annotation(*args, **kwargs)
+
+[docs] def create_mass_action(self, *args, **kwargs):
+ """
+ Initializes the mass action propensity function given
+ self.reactants and a single parameter value.
+ """
+ from gillespy2.core import log
+ log.warning(
+ """
+ Reaction.create_mass_action has been deprecated. Future releases of GillesPy2 may
+ not support this feature.
+ """
+ )
+ self._create_mass_action(*args, **kwargs)
+
+[docs] @classmethod
+ def from_json(cls, json_object):
+ new = Reaction.__new__(Reaction)
+ new.__dict__ = json_object
+
+ # Same as in to_dict(), but we need to reverse it back into its original representation.
+ new.products = { x["key"]: x["value"] for x in json_object["products"] }
+ new.reactants = { x["key"]: x["value"] for x in json_object["reactants"] }
+
+ if new.massaction and new.type == "mass-action" and new.marate is not None:
+ new._create_mass_action()
+
+ new.validate(coverage="all")
+
+ return new
+
[docs] def sanitized_propensity_function(self, species_mappings, parameter_mappings, ode=False):
names = sorted(list(species_mappings.keys()) + list(parameter_mappings.keys()), key=lambda x: len(x),
reverse=True)
@@ -481,6 +570,101 @@ Source code for gillespy2.core.reaction
sanitized_propensity = sanitized_propensity.replace(name, "{" + str(id) + "}")
return sanitized_propensity.format(*replacements)
+[docs] def set_annotation(self, annotation):
+ """
+ Add an annotation to this reaction.
+
+ :param annotation: Annotation note to be added to reaction
+ :type annotation: str
+ """
+ if annotation is None:
+ raise ReactionError("annotation can't be None type.")
+
+ self.validate(coverage="annotation", annotation=annotation)
+
+ self.annotation = annotation
+
+[docs] def set_propensities(self, propensity_function=None, ode_propensity_function=None):
+ """
+ Change the reaction to a customized reaction and set the propensities.
+
+ :param propensity_function: The custom propensity function for the reaction. Must be evaluable in the
+ namespace of the reaction using C operations.
+ :type propensity_function: str
+
+ :param ode_propensity_function: The custom ode propensity function for the reaction. Must be evaluable in the
+ namespace of the reaction using C operations.
+ :type ode_propensity_function: str
+ """
+ if isinstance(propensity_function, (int, float)):
+ propensity_function = str(propensity_function)
+ if isinstance(ode_propensity_function, (int, float)):
+ ode_propensity_function = str(ode_propensity_function)
+
+ self.validate(propensity_function=propensity_function, ode_propensity_function=ode_propensity_function, coverage="propensities")
+
+ self.propensity_function = propensity_function
+ self.ode_propensity_function = ode_propensity_function
+ self.marate = None
+
+ self.massaction = False
+ self.type = "customized"
+ if self.propensity_function is None:
+ self.propensity_function = self.ode_propensity_function
+ if self.ode_propensity_function is None:
+ self.ode_propensity_function = self.propensity_function
+ propensity = self._create_custom_propensity(self.propensity_function)
+ self.propensity_function = propensity
+ ode_propensity = self._create_custom_propensity(self.ode_propensity_function)
+ self.ode_propensity_function = ode_propensity
+
+ self.validate(coverage="initialized")
+
+[docs] def set_rate(self, rate):
+ """
+ Change the reaction to a mass-action reaction and set the rate.
+
+ :param rate: The rate of the mass-action reaction, take care to note the units.
+ :type rate: int | float | str | Parameter
+ """
+ if rate is None:
+ raise ReactionError("rate can't be None type")
+
+ if isinstance(rate, Parameter) or type(rate).__name__ == "Parameter":
+ rate = rate.name
+ elif isinstance(rate, (int, float)):
+ rate = str(rate)
+
+ self.validate(marate=rate, coverage="marate")
+
+ self.marate = rate
+ self.massaction = True
+ self.type = "mass-action"
+ self._create_mass_action()
+
+ self.validate(coverage="initialized")
+
+[docs] def setType(self, rxntype):
+ """
+ Sets reaction type to either "mass-action" or "customized" (deprecated)
+
+ :param rxntype: Either "mass-action" or "customized"
+ :type rxntype: str
+ """
+ from gillespy2.core import log
+ log.warning(
+ """
+ Reaction.setType has been deprecated. Future releases of GillesPy2 may not support this feature.
+ Set propensity_function for Reaction.type="customized" or rate for Reaction.type="mass-action" instead.
+ """
+ )
+
+ if rxntype.lower() not in ('mass-action', 'customized'):
+ raise ReactionError("Invalid reaction type.")
+ self.type = rxntype.lower()
+
+ self.massaction = False if self.type == 'customized' else True
+
[docs] def to_dict(self):
temp = vars(self).copy()
@@ -493,16 +677,146 @@ Source code for gillespy2.core.reaction
return temp
-[docs] @classmethod
- def from_json(cls, json_object):
- new = Reaction.__new__(Reaction)
- new.__dict__ = json_object
-
- # Same as in to_dict(), but we need to reverse it back into its original representation.
- new.products = { x["key"]: x["value"] for x in json_object["products"] }
- new.reactants = { x["key"]: x["value"] for x in json_object["reactants"] }
-
- return new
+[docs] def validate(self, reactants=None, products=None, propensity_function=None,
+ ode_propensity_function=None, marate=None, annotation=None, coverage="build"):
+ """
+ Check if the reaction is properly formatted.
+ Does nothing on sucesss, raises and error on failure.
+ """
+ if coverage in ("all", "build", "name"):
+ if self.name is None:
+ raise ReactionError("name can't be None type.")
+ if not isinstance(self.name, str):
+ raise ReactionError("name must be of type str.")
+ if self.name == "":
+ raise ReactionError("name can't be an empty string.")
+
+ if coverage in ("all", "build", "reactants"):
+ if self.reactants is None:
+ raise ReactionError("recants can't be None type.")
+
+ if reactants is None:
+ reactants = self.reactants
+
+ if reactants is not None:
+ if not isinstance(reactants, dict):
+ raise ReactionError("reactants must be of type dict.")
+
+ for species, stoichiometry in reactants.items():
+ if species is None:
+ raise ReactionError("species in reactants can't be None type.")
+ if not (isinstance(species, (str, Species)) or type(species).__name__ == 'Species'):
+ raise ReactionError("species in reactants must be of type str or GillesPy2.Species.")
+ if species == "":
+ raise ReactionError("species in reactants can't be an empty string.")
+
+ if stoichiometry is None:
+ raise ReactionError("stoichiometry in reactants can't be None type.")
+ if not isinstance(stoichiometry, int) or stoichiometry <= 0:
+ raise ReactionError("stoichiometry in reactants must greater than 0 and of type int.")
+
+ if coverage in ("all", "build", "products"):
+ if self.products is None:
+ raise ReactionError("products can't be None type.")
+
+ if products is None:
+ products = self.products
+
+ if products is not None:
+ if not isinstance(products, dict):
+ raise ReactionError("products must be of type dict.")
+
+ for species, stoichiometry in products.items():
+ if species is None:
+ raise ReactionError("species in products can't be None Type.")
+ if not (isinstance(species, (str, Species)) or type(species).__name__ == 'Species'):
+ raise ReactionError("species in products must be of type str or GillesPy2.Species.")
+ if species == "":
+ raise ReactionError("species in products can't be an empty string.")
+
+ if stoichiometry is None:
+ raise ReactionError("stoichiometry in products can't be None type.")
+ if not isinstance(stoichiometry, int) or stoichiometry <= 0:
+ raise ReactionError("stoichiometry in products must greater than 0 and of type int.")
+
+ if coverage in ("all", "build", "propensities"):
+ if propensity_function is None:
+ propensity_function = self.propensity_function
+
+ if propensity_function is not None:
+ if not isinstance(propensity_function, str):
+ raise ReactionError("propensity_function must be of type str.")
+ if propensity_function == "":
+ raise ReactionError("propensity_function can't be an empty string.")
+
+ if coverage in ("all", "build", "propensities"):
+ if ode_propensity_function is None:
+ ode_propensity_function = self.ode_propensity_function
+
+ if ode_propensity_function is not None:
+ if not isinstance(ode_propensity_function, str):
+ raise ReactionError("ode_propensity_function must be of type str.")
+ if ode_propensity_function == "":
+ raise ReactionError("ode_propensity_function can't be an empty string.")
+
+ if coverage in ("all", "build", "marate"):
+ if marate is None:
+ marate = self.marate
+
+ if marate is not None:
+ if not (isinstance(marate, (str, Parameter)) or type(marate).__name__ == 'Parameter'):
+ raise ReactionError("rate must be of type str or GillesPy2.Parameter.")
+ if marate == "":
+ raise ReactionError("rate can't be an empty string.")
+
+ if coverage == "build" and not hasattr(self, "massaction"):
+ has_prop = propensity_function is not None or ode_propensity_function is not None
+ if marate is not None and has_prop:
+ raise ReactionError("You cannot set the rate and simultaneously set propensity functions.")
+ if marate is None and not has_prop:
+ raise ReactionError("You must specify either a mass-action rate or propensity functions.")
+
+ if coverage in ("all", "build", "annotation"):
+ if annotation is None:
+ annotation = self.annotation
+
+ if annotation is not None and not isinstance(annotation, str):
+ raise ReactionError("annotation must be of type str.")
+
+ if coverage in ("all", "initialized"):
+ if len(self.reactants) == 0 and len(self.products) == 0:
+ raise ReactionError("You must have a non-zero number of reactants or products.")
+ if self.propensity_function is None:
+ raise ReactionError("propensity_function can't be None type.")
+ if self.ode_propensity_function is None:
+ raise ReactionError("ode_propensity_function can't be None type.")
+ if self.marate is None:
+ if self.massaction and self.type == "mass-action":
+ raise ReactionError("You must specify either a mass-action rate or propensity functions")
+ if self.massaction or self.type == "mass-action":
+ errmsg = "Invalid customized reaction. Customized reactions require massaction=False and type='customized'"
+ raise ReactionError(errmsg)
+ else:
+ if not self.massaction and self.type == "customized":
+ raise ReactionError("You cannot set the rate and simultaneously set propensity functions.")
+ if not self.massaction or self.type == "customized":
+ errmsg = "Invalid mass-action reaction. Mass-action reactions require massaction=True and type='mass-action'"
+ raise ReactionError(errmsg)
+
+[docs] def verify(self, *args, **kwargs):
+ """
+ Check if the reaction is properly formatted.
+ Does nothing on sucesss, raises and error on failure.
+ """
+ from gillespy2.core import log
+ log.warning(
+ """
+ Reaction.verify has been deprecated. Future releases of GillesPy2 may
+ not support this feature. Use Reaction.validate instead.
+ """
+ )
+
+ self.validate(*args, **kwargs)
diff --git a/docs/build/html/_modules/gillespy2/core/results.html b/docs/build/html/_modules/gillespy2/core/results.html
index 167fbfa88..ee87cb07d 100644
--- a/docs/build/html/_modules/gillespy2/core/results.html
+++ b/docs/build/html/_modules/gillespy2/core/results.html
@@ -5,7 +5,7 @@
- gillespy2.core.results — GillesPy2 1.6.9 documentation
+ gillespy2.core.results — GillesPy2 1.6.10 documentation
@@ -340,12 +340,12 @@ Source code for gillespy2.core.results
size1 = len(self.data[0]['time'])
size2 = len(self.data[0])
- for trajectory in range(0,len(self.data)):
+ for trajectory in range(0, len(self.data)):
newArray = np.zeros((size1, size2))
for i, key in enumerate(self.data[trajectory]):
newArray[:, i] = self.data[trajectory][key]
results.append(newArray)
- return results
+ return np.array(results)
[docs] @classmethod
def build_from_solver_results(cls, solver, live_output_options):
@@ -920,7 +920,8 @@ Source code for gillespy2.core.results
upperBound = [a+b for a, b in zip(average_result[species], stddev_trajectory[species])]
plt.fill_between(average_result['time'], lowerBound, upperBound, color='whitesmoke')
- plt.plot(average_result['time'], lowerBound, upperBound, color='grey', linestyle='dashed')
+ plt.plot(average_result['time'], upperBound, color='grey', linestyle='dashed')
+ plt.plot(average_result['time'], lowerBound, color='grey', linestyle='dashed')
plt.plot(average_result['time'], average_result[species], label=species)
if not show_title:
diff --git a/docs/build/html/_modules/gillespy2/core/sortableobject.html b/docs/build/html/_modules/gillespy2/core/sortableobject.html
index cfe61494c..01d98b506 100644
--- a/docs/build/html/_modules/gillespy2/core/sortableobject.html
+++ b/docs/build/html/_modules/gillespy2/core/sortableobject.html
@@ -5,7 +5,7 @@
- gillespy2.core.sortableobject — GillesPy2 1.6.9 documentation
+ gillespy2.core.sortableobject — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/core/species.html b/docs/build/html/_modules/gillespy2/core/species.html
index b3d5f43e3..14a6a2b9e 100644
--- a/docs/build/html/_modules/gillespy2/core/species.html
+++ b/docs/build/html/_modules/gillespy2/core/species.html
@@ -5,7 +5,7 @@
- gillespy2.core.species — GillesPy2 1.6.9 documentation
+ gillespy2.core.species — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/core/timespan.html b/docs/build/html/_modules/gillespy2/core/timespan.html
index eaf9f8258..ba289dccb 100644
--- a/docs/build/html/_modules/gillespy2/core/timespan.html
+++ b/docs/build/html/_modules/gillespy2/core/timespan.html
@@ -5,7 +5,7 @@
- gillespy2.core.timespan — GillesPy2 1.6.9 documentation
+ gillespy2.core.timespan — GillesPy2 1.6.10 documentation
@@ -142,6 +142,9 @@ Source code for gillespy2.core.timespan
self.validate()
+ def __str__(self):
+ return self.items.__str__()
+
def __eq__(self, o):
return self.items.__eq__(o).all()
@@ -163,7 +166,7 @@ Source code for gillespy2.core.timespan
Creates a timespan using the form np.linspace(0, <t>, <num_points, inclusive>).
:param t: End time for the simulation.
- :type t: int
+ :type t: float | int
:param num_points: Number of sample points for the species populations during the simulation.
:type num_points: int
@@ -173,8 +176,8 @@ Source code for gillespy2.core.timespan
:raises TimespanError: t or num_points are None, <= 0, or invalid type.
"""
- if t is None or not isinstance(t, int) or t <= 0:
- raise TimespanError("t must be a positive int.")
+ if t is None or not isinstance(t, (int, float)) or t <= 0:
+ raise TimespanError("t must be a positive float or int.")
if num_points is not None and (not isinstance(num_points, int) or num_points <= 0):
raise TimespanError("num_points must be a positive int.")
@@ -192,15 +195,15 @@ Source code for gillespy2.core.timespan
:type increment: float | int
:param t: End time for the simulation.
- :type t: int
+ :type t: float | int
:returns: Timespan for the model.
:rtype: gillespy2.TimeSpan
:raises TimespanError: t or increment are None, <= 0, or invalid type.
"""
- if t is None or not isinstance(t, int) or t <= 0:
- raise TimespanError("t must be a positive int.")
+ if t is None or not isinstance(t, (int, float)) or t <= 0:
+ raise TimespanError("t must be a positive floar or int.")
if not isinstance(increment, (float, int)) or increment <= 0:
raise TimespanError("increment must be a positive float or int.")
diff --git a/docs/build/html/_modules/gillespy2/sbml/SBMLexport.html b/docs/build/html/_modules/gillespy2/sbml/SBMLexport.html
index 0f70b4cbb..15e510199 100644
--- a/docs/build/html/_modules/gillespy2/sbml/SBMLexport.html
+++ b/docs/build/html/_modules/gillespy2/sbml/SBMLexport.html
@@ -5,7 +5,7 @@
- gillespy2.sbml.SBMLexport — GillesPy2 1.6.9 documentation
+ gillespy2.sbml.SBMLexport — GillesPy2 1.6.10 documentation
@@ -215,7 +215,7 @@ Source code for gillespy2.sbml.SBMLexport
for name, rule in rate_rule_list.items():
r_rule = model.createRateRule()
r_rule.setId(name)
- r_rule.setVariable(rule.variable)
+ r_rule.setVariable(rule.variable.name)
formula = __get_math(rule.formula)
r_rule.setMath(formula)
@@ -223,7 +223,7 @@ Source code for gillespy2.sbml.SBMLexport
for name, rule in assignment_rule_list.items():
a_rule = model.createAssignmentRule()
a_rule.setId(name)
- a_rule.setVariable(rule.variable)
+ a_rule.setVariable(rule.variable.name)
formula = __get_math(rule.formula)
a_rule.setMath(formula)
@@ -252,6 +252,8 @@ Source code for gillespy2.sbml.SBMLexport
:type path: str
"""
+ model.compile_prep()
+
if path is None:
path = f"{model.name}.xml"
diff --git a/docs/build/html/_modules/gillespy2/sbml/SBMLimport.html b/docs/build/html/_modules/gillespy2/sbml/SBMLimport.html
index 2be057e82..9aa412597 100644
--- a/docs/build/html/_modules/gillespy2/sbml/SBMLimport.html
+++ b/docs/build/html/_modules/gillespy2/sbml/SBMLimport.html
@@ -5,7 +5,7 @@
- gillespy2.sbml.SBMLimport — GillesPy2 1.6.9 documentation
+ gillespy2.sbml.SBMLimport — GillesPy2 1.6.10 documentation
@@ -243,7 +243,10 @@ Source code for gillespy2.sbml.SBMLimport
for i in range(sbml_model.getNumCompartments()):
compartment = sbml_model.getCompartment(i)
name = compartment.getId()
- value = compartment.getSize()
+ if compartment.isSetSize():
+ value = compartment.getSize()
+ else:
+ value = 1
if name == "vol":
gillespy_model.volume = value
@@ -313,26 +316,45 @@ Source code for gillespy2.sbml.SBMLimport
p_set = set()
# get reactants
for j in range(reaction.getNumReactants()):
- species = reaction.getReactant(j)
- if species.getSpecies() == "EmptySet": continue
+ reactant = reaction.getReactant(j)
+ species = reactant.getSpecies()
+
+ if species == "EmptySet": continue
else:
- if species.getSpecies() in r_set:
- reactants[species.getSpecies()] += species.getStoichiometry()
+ stoichiometry = reactant.getStoichiometry()
+ if isinstance(stoichiometry, float):
+ if int(stoichiometry) != stoichiometry:
+ logmsg = f"Reaction {name} contains a float stoichiometry for reactant {species}. "
+ logmsg += "Please check your model as this may cause inaccuracies in the results."
+ gillespy2.log.warning(logmsg)
+ stoichiometry = int(stoichiometry)
+
+ if species in r_set:
+ reactants[species] += stoichiometry
else:
- r_set.add(species.getSpecies())
- reactants[species.getSpecies()] = species.getStoichiometry()
+ r_set.add(species)
+ reactants[species] = stoichiometry
# get products
for j in range(reaction.getNumProducts()):
- species = reaction.getProduct(j)
+ product = reaction.getProduct(j)
+ species = product.getSpecies()
- if species.getSpecies() == "EmptySet": continue
+ if species == "EmptySet": continue
else:
- if species.getSpecies() in p_set:
- products[species.getSpecies()] += species.getStoichiometry()
+ stoichiometry = product.getStoichiometry()
+ if isinstance(stoichiometry, float):
+ if int(stoichiometry) != stoichiometry:
+ logmsg = f"Reaction {name} contains a float stoichiometry for product {species}. "
+ logmsg += "Please check your model as this may cause inaccuracies in the results."
+ gillespy2.log.warning(logmsg)
+ stoichiometry = int(stoichiometry)
+
+ if species in p_set:
+ products[species] += stoichiometry
else:
- p_set.add(species.getSpecies())
- products[species.getSpecies()] = species.getStoichiometry()
+ p_set.add(species)
+ products[species] = stoichiometry
gillespy_reaction = gillespy2.Reaction(name=name, reactants=reactants, products=products,
propensity_function=propensity)
@@ -368,7 +390,7 @@ Source code for gillespy2.sbml.SBMLimport
gillespy_rule = gillespy2.AssignmentRule(name=rule_name, variable=rule_variable,
formula=rule_string)
gillespy_model.add_assignment_rule(gillespy_rule)
- init_state[gillespy_rule.variable]=eval(gillespy_rule.formula, {**init_state, **eval_globals})
+ init_state[gillespy_rule.variable.name]=eval(gillespy_rule.formula, {**init_state, **eval_globals})
if rule.isRate():
gillespy_rule = gillespy2.RateRule(name=rule_name, variable=rule_variable,
@@ -464,7 +486,7 @@ Source code for gillespy2.sbml.SBMLimport
if variable in gillespy_model.listOfSpecies:
gillespy_model.listOfSpecies[variable].initial_value = assigned_value
elif variable in gillespy_model.listOfParameters:
- gillespy_model.listOfParameters[variable].set_expression(assigned_value)
+ gillespy_model.listOfParameters[variable].expression = assigned_value
def __resolve_evals(gillespy_model, init_state):
while True:
@@ -483,11 +505,21 @@ Source code for gillespy2.sbml.SBMLimport
if not len(successful): break
for var in successful: del postponed_evals[var]
-[docs]def convert(filename, model_name=None, gillespy_model=None):
+[docs]def convert(filename, model_name=None, gillespy_model=None, report_silently_with_sbml_error=False):
sbml_model, errors = __read_sbml_model(filename)
+
if sbml_model is None:
- return None, errors
+ if report_silently_with_sbml_error:
+ return None, errors
+ errs = '\n\t'.join(errors)
+ raise SBMLError(f"SBML model import failed. Reason Given: \n\t{errs}")
+
+ if len(errors) > 0 and not report_silently_with_sbml_error:
+ from gillespy2 import log
+ errs = '\n\t'.join(errors)
+ log.warning(f"Error were detected in the SBML model. Error: \n\t{errs}")
+
if model_name is None:
model_name = sbml_model.getName()
if gillespy_model is None:
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/build/build_engine.html b/docs/build/html/_modules/gillespy2/solvers/cpp/build/build_engine.html
index 10b6e325a..fcb56bcc1 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/build/build_engine.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/build/build_engine.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.build.build_engine — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.build.build_engine — GillesPy2 1.6.10 documentation
@@ -119,6 +119,7 @@ Source code for gillespy2.solvers.cpp.build.build_engine
import os
import shutil
import tempfile
+import platform
from pathlib import Path
from typing import Union
@@ -136,7 +137,10 @@ Source code for gillespy2.solvers.cpp.build.build_engine
def __init__(self, debug: bool = False, output_dir: str = None):
self.self_dir = Path(__file__).parent
self.cpp_dir = self.self_dir.joinpath("../c_base").resolve()
- self.makefile = self.cpp_dir.joinpath("Makefile")
+ if platform.system() == 'Windows':
+ self.makefile = self.cpp_dir.joinpath("Makefile.win32")
+ else:
+ self.makefile = self.cpp_dir.joinpath("Makefile")
self.src_template_dir = self.cpp_dir.joinpath("template")
self.output_dir = output_dir
@@ -213,8 +217,8 @@ Source code for gillespy2.solvers.cpp.build.build_engine
# If a raw GillesPy2 model was provided, convert it to a sanitized model.
if isinstance(model, gillespy2.Model):
model = template_gen.SanitizedModel(model, variable=variable)
- elif not isinstance(model, template_gen.SanitizedModel):
- raise TypeError(f"Build engine expected gillespy2.Model or SanitizedModel type: received {type(model)}")
+ elif not isinstance(model, template_gen.SanitizedModel) and type(model).__name__ == "SanitizedModel":
+ raise TypeError(f"Build engine expected gillespy2.Model or SanitizedModel type: received {type(model)} , __name__={type(model).__name__}")
# Build the template and write it to the temp directory and remove the sample template_definitions header.
template_file = self.template_dir.joinpath(self.template_definitions_name)
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/build/expression.html b/docs/build/html/_modules/gillespy2/solvers/cpp/build/expression.html
index 4ea8ac712..870a1fcbe 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/build/expression.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/build/expression.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.build.expression — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.build.expression — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/build/make.html b/docs/build/html/_modules/gillespy2/solvers/cpp/build/make.html
index 501f22c4d..ca7cb3d40 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/build/make.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/build/make.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.build.make — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.build.make — GillesPy2 1.6.10 documentation
@@ -193,7 +193,9 @@ Source code for gillespy2.solvers.cpp.build.make
raise gillespyError.BuildError(f"Error encountered during execution of Makefile target: '{target}'.\n"
f"Return code: {result.returncode}"
f"- stdout: {result.stdout.decode('utf-8', errors='ignore')}\n"
- f"- stderr: {result.stderr.decode('utf-8', errors='ignore')}\n")
+ f"- stderr: {result.stderr.decode('utf-8', errors='ignore')}\n"
+ f"- make_cmd: {make_cmd}\n"
+ f"- os.listdir({os.path.join(self.cbase_dir,'template')}): {os.listdir(os.path.join(self.cbase_dir,'template'))}\n")
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/build/template_gen.html b/docs/build/html/_modules/gillespy2/solvers/cpp/build/template_gen.html
index fac600a78..a100d83c4 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/build/template_gen.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/build/template_gen.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.build.template_gen — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.build.template_gen — GillesPy2 1.6.10 documentation
@@ -189,6 +189,8 @@ Source code for gillespy2.solvers.cpp.build.template_gen
# Reactions: maps reaction names to their stoichiometry matrix.
# Stoichiometry matrix maps a sanitized species name to its stoichiometry.
self.reactions: "OrderedDict[str, dict[str, int]]" = OrderedDict()
+ self.reaction_reactants: "OrderedDict[str, dict[str, int]]" = OrderedDict()
+ self.reaction_products: "OrderedDict[str, dict[str, int]]" = OrderedDict()
# Rate Rules: maps sanitized species names to their corresponding rate rule expression.
self.rate_rules: "OrderedDict[str, str]" = OrderedDict()
# Options: custom definitions that can be supplied by the solver, maps macros to their definitions.
@@ -224,15 +226,17 @@ Source code for gillespy2.solvers.cpp.build.template_gen
:type reaction: gillespy2.Reaction
"""
self.reactions[reaction.name] = {spec: int(0) for spec in self.species_names.values()}
+ self.reaction_reactants[reaction.name] = {spec: int(0) for spec in self.species_names.values()}
+ self.reaction_products[reaction.name] = {spec: int(0) for spec in self.species_names.values()}
for reactant, stoich_value in reaction.reactants.items():
- if isinstance(reactant, Species):
- reactant = self.species_names[reactant.name]
+ reactant = self.species_names[reactant.name]
self.reactions[reaction.name][reactant] -= int(stoich_value)
+ self.reaction_reactants[reaction.name][reactant] = int(stoich_value)
for product, stoich_value in reaction.products.items():
- if isinstance(product, Species):
- product = self.species_names[product.name]
+ product = self.species_names[product.name]
self.reactions[reaction.name][product] += int(stoich_value)
+ self.reaction_products[reaction.name][product] = int(stoich_value)
return self
@@ -503,18 +507,30 @@ Source code for gillespy2.solvers.cpp.build.template_gen
"""
num_reactions = str(len(model.reactions))
reaction_set = OrderedDict()
+ reactants_set = OrderedDict()
+ products_set = OrderedDict()
for rxn_name, reaction in model.reactions.items():
stoich = [str(int(reaction[species])) for species in model.species_names.values()]
reaction_set[rxn_name] = f"{{{','.join(stoich)}}}"
+ for rxn_name, reaction_reactants in model.reaction_reactants.items():
+ reactants_count = [str(int(reaction_reactants[species])) for species in model.species_names.values()]
+ reactants_set[rxn_name] = f"{{{','.join(reactants_count)}}}"
+ for rxn_name, reaction_products in model.reaction_products.items():
+ products_count = [str(int(reaction_products[species])) for species in model.species_names.values()]
+ products_set[rxn_name] = f"{{{','.join(products_count)}}}"
reaction_names = " ".join([f"REACTION_NAME({rxn})" for rxn in reaction_set.keys()])
reaction_set = f"{{{','.join(reaction_set.values())}}}"
+ reactants_set = f"{{{','.join(reactants_set.values())}}}"
+ products_set = f"{{{','.join(products_set.values())}}}"
return {
"GPY_NUM_REACTIONS": num_reactions,
- "GPY_REACTIONS": reaction_set,
"GPY_REACTION_NAMES": reaction_names,
+ "GPY_REACTIONS": reaction_set,
+ "GPY_REACTION_REACTANTS": reactants_set,
+ "GPY_REACTION_PRODUCTS": products_set,
}
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/c_decoder.html b/docs/build/html/_modules/gillespy2/solvers/cpp/c_decoder.html
index c5ebd025b..f492a40d6 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/c_decoder.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/c_decoder.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.c_decoder — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.c_decoder — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/c_solver.html b/docs/build/html/_modules/gillespy2/solvers/cpp/c_solver.html
index d92924600..351e4dc29 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/c_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/c_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.c_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.c_solver — GillesPy2 1.6.10 documentation
@@ -122,6 +122,7 @@ Source code for gillespy2.solvers.cpp.c_solver
import signal
import threading
import queue
+import platform
import numpy
@@ -129,6 +130,7 @@
Source code for gillespy2.solvers.cpp.c_solver
from concurrent.futures import ThreadPoolExecutor
from typing import Union
+import gillespy2
from gillespy2.core import Model
from gillespy2.core import Results
from gillespy2.core import log
@@ -171,6 +173,9 @@
Source code for gillespy2.solvers.cpp.c_solver
"Please install/configure 'g++' and 'make' on your system, to ensure that GillesPy2 C solvers will run properly."
)
+ if platform.system() == "Windows" and " " in gillespy2.__file__:
+ raise gillespy2Error.SimulationError("GillesPy2 does not support spaces in its path on Windows systems.")
+
self.delete_directory = False
self.model = copy.deepcopy(model)
self.resume = resume
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/ode_c_solver.html b/docs/build/html/_modules/gillespy2/solvers/cpp/ode_c_solver.html
index 2570edde9..e22b09512 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/ode_c_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/ode_c_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.ode_c_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.ode_c_solver — GillesPy2 1.6.10 documentation
@@ -126,18 +126,71 @@ Source code for gillespy2.solvers.cpp.ode_c_solver
from .c_solver import CSolver, SimulationReturnCode
[docs]class ODECSolver(GillesPySolver, CSolver):
+ """
+ This Solver produces the deterministic continuous solution via Ordinary Differential Equations.
+ Uses integrators from SUNDIALS to perform calculations used to produce solutions.
+ """
+
name = "ODECSolver"
target = "ode"
+[docs] @staticmethod
+ def get_supported_integrator_options():
+ return {
+ "rtol",
+ "atol",
+ "max_step",
+ }
+
[docs] def get_solver_settings(self):
"""
+ Returns a list of arguments supported by odc_c_solver.run.
:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'timeout', 'increment', 'seed', 'debug', 'profile')
[docs] def run(self=None, model: Model = None, t: int = None, number_of_trajectories: int = 1, timeout: int = 0,
increment: int = None, seed: int = None, debug: bool = False, profile: bool = False, variables={},
- resume=None, live_output: str = None, live_output_options: dict = {}, **kwargs):
+ resume=None, live_output: str = None, live_output_options: dict = {}, integrator_options: "dict[str, float]" = None, **kwargs):
+
+ """
+ :param model: The model on which the solver will operate. (Deprecated)
+ :type model: gillespy2.Model
+
+ :param t: End time of simulation.
+ :type t: int
+
+ :param number_of_trajectories: Number of trajectories to simulate.
+ This is deterministic and will always have same results.
+ :type number_of_trajectories: int
+
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :param increment: Time step increment for plotting.
+ :type increment: float
+
+ :param seed: The random seed for the simulation. Optional, defaults to None.
+ :type seed: int
+
+ :param variables: Dictionary of species and their data that will override existing species data.
+ :type variables: dict
+
+ :param resume: Result of a previously run simulation, to be resumed.
+ :type resume: gillespy2.Results
+
+ :param live_output: The type of output to be displayed by solver. Can be "progress", "text", or "graph".
+ :type live_output: str
+
+ :param live_output_options: Dictionary that contains options for live_output. By default {"interval":1}.
+ "interval" specifies seconds between displaying.
+ "clear_output" specifies if display should be refreshed with each display.
+ :type live_output_options: dict
+
+ :returns: A result object containing the results of the simulation.
+ :rtype: gillespy2.Results
+ """
from gillespy2 import log
@@ -163,7 +216,7 @@ Source code for gillespy2.solvers.cpp.ode_c_solver
raise SimulationError("A model is required to run the simulation.")
self._set_model(model=model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
@@ -200,6 +253,9 @@ Source code for gillespy2.solvers.cpp.ode_c_solver
"init_pop": populations,
"parameters": parameter_values
})
+ if integrator_options is not None:
+ integrator_options = ODECSolver.validate_integrator_options(integrator_options)
+ args.update(integrator_options)
seed = self._validate_seed(seed)
if seed is not None:
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/ssa_c_solver.html b/docs/build/html/_modules/gillespy2/solvers/cpp/ssa_c_solver.html
index c37bfedba..97593abfb 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/ssa_c_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/ssa_c_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.ssa_c_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.ssa_c_solver — GillesPy2 1.6.10 documentation
@@ -127,12 +127,18 @@ Source code for gillespy2.solvers.cpp.ssa_c_solver
from .c_solver import CSolver, SimulationReturnCode
[docs]class SSACSolver(GillesPySolver, CSolver):
+ """
+ This solver produces simulations of systems via Stochastic Simulation Algorithm.
+ """
+
name = "SSACSolver"
target = "ssa"
[docs] def get_solver_settings(self):
"""
+ Returns a list of arguments supported by ssa_c_solver.run.
:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'timeout', 'increment', 'seed', 'debug', 'profile')
@@ -142,6 +148,44 @@ Source code for gillespy2.solvers.cpp.ssa_c_solver
from gillespy2 import log
+ """
+ :param model: The model on which the solver will operate. (Deprecated)
+ :type model: gillespy2.Model
+
+ :param t: End time of simulation.
+ :type t: int
+
+ :param number_of_trajectories: The number of times to sample the chemical master equation. Each
+ trajectory will be returned at the end of the simulation. By default number_of_trajectories = 1.
+ :type number_of_trajectories: int
+
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :param increment: Time step increment for plotting.
+ :type increment: float
+
+ :param seed: The random seed for the simulation. Optional, defaults to None.
+ :type seed: int
+
+ :param variables: Dictionary of species and their data that will override existing species data.
+ :type variables: dict
+
+ :param resume: Result of a previously run simulation, to be resumed.
+ :type resume: gillespy2.Results
+
+ :param live_output: The type of output to be displayed by solver. Can be "progress", "text", or "graph".
+ :type live_output: str
+
+ :param live_output_options: dictionary contains options for live_output. By default {"interval":1}.
+ "interval" specifies seconds between displaying.
+ "clear_output" specifies if display should be refreshed with each display.
+ :type live_output_options: dict
+
+ :returns: A result object containing the results of the simulation.
+ :rtype: gillespy2.Results
+ """
+
if self is None:
# Post deprecation block
# raise SimulationError("SSACSolver must be instantiated to run the simulation")
@@ -164,7 +208,7 @@ Source code for gillespy2.solvers.cpp.ssa_c_solver
raise SimulationError("A model is required to run the simulation.")
self._set_model(model=model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/tau_hybrid_c_solver.html b/docs/build/html/_modules/gillespy2/solvers/cpp/tau_hybrid_c_solver.html
index f934d1cfd..0c3750f7f 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/tau_hybrid_c_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/tau_hybrid_c_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.tau_hybrid_c_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.tau_hybrid_c_solver — GillesPy2 1.6.10 documentation
@@ -107,6 +107,7 @@ Source code for gillespy2.solvers.cpp.tau_hybrid_c_solver
from gillespy2.core import GillesPySolver, Model, Event, RateRule
from gillespy2.core.gillespyError import *
from typing import Union
+from typing import Set
from enum import IntEnum
from gillespy2.core import Results
@@ -114,11 +115,21 @@ Source code for gillespy2.solvers.cpp.tau_hybrid_c_solver
from gillespy2.solvers.cpp.build.template_gen import SanitizedModel
[docs]class TauHybridCSolver(GillesPySolver, CSolver):
+ """
+ This solver uses a root-finding interpretation of the direct SSA method,
+ along with ODE solvers to simulate ODE and Stochastic systems
+ interchangeably or simultaneously.
+ """
+
name = "TauHybridCSolver"
target = "hybrid"
+ UNKNOWN = 1
+ LOOP_OVER_INTEGRATE = 2
+ INTEGRATOR_FAILED = 3
+ INVALID_AFTER_SSA = 4
+ NEGATIVE_STATE_NO_SSA_REACTION = 5
@classmethod
def __create_options(cls, sanitized_model: "SanitizedModel") -> "SanitizedModel":
@@ -171,7 +182,7 @@ Source code for gillespy2.solvers.cpp.tau_hybrid_c_solver
# Explicit cast to bool for safety, in case boundary_condition is given weird values
boundary_keyword = boundary_condition_types[int(bool(species.boundary_condition))]
# Example: SPECIES_MODE(2, 10, CONTINUOUS_MODE, BOUNDARY)
- entry = f"SPECIES_MODE({spec_id},{species.switch_min},{mode_keyword},{boundary_keyword})"
+ entry = f"SPECIES_MODE({spec_id},{species.switch_min},{species.switch_tol},{mode_keyword},{boundary_keyword})"
species_mode_list.append(entry)
# EVENT(event_id, {targets}, trigger, delay, priority, use_trigger, use_persist)
@@ -255,6 +266,10 @@ Source code for gillespy2.solvers.cpp.tau_hybrid_c_solver
RateRule,
}
+[docs] @classmethod
+ def get_supported_integrator_options(cls) -> "Set[str]":
+ return { "rtol", "atol", "max_step" }
+
def _build(self, model: "Union[Model, SanitizedModel]", simulation_name: str, variable: bool, debug: bool = False,
custom_definitions=None) -> str:
variable = variable or len(model.listOfEvents) > 0
@@ -264,19 +279,71 @@ Source code for gillespy2.solvers.cpp.tau_hybrid_c_solver
return super()._build(sanitized_model, simulation_name, variable, debug)
def _handle_return_code(self, return_code: "int") -> "int":
+ if return_code == TauHybridCSolver.ErrorStatus.UNKNOWN:
+ raise ExecutionError("C++ solver failed (no error code given).")
if return_code == TauHybridCSolver.ErrorStatus.LOOP_OVER_INTEGRATE:
raise ExecutionError("Loop over integrate exceeded, problem space is too stiff")
+ if return_code == TauHybridCSolver.ErrorStatus.INTEGRATOR_FAILED:
+ raise ExecutionError("Sundials ODE solver failed with 'BAD_STEP_SIZE'")
+ if return_code == TauHybridCSolver.ErrorStatus.INVALID_AFTER_SSA:
+ raise ExecutionError("Invalid state after single SSA step")
+ if return_code == TauHybridCSolver.ErrorStatus.NEGATIVE_STATE_NO_SSA_REACTION:
+ raise ExecutionError("Negative State detected in step, and no reaction found to fire.")
+
return super()._handle_return_code(return_code)
[docs] def get_solver_settings(self):
"""
+ Returns a list of arguments supported by tau_hybrid_c_solver.run.
:return: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'timeout', 'increment', 'seed', 'debug', 'profile')
[docs] def run(self=None, model: Model = None, t: int = None, number_of_trajectories: int = 1, timeout: int = 0,
increment: int = None, seed: int = None, debug: bool = False, profile: bool = False, variables={},
- resume=None, live_output: str = None, live_output_options: dict = {}, tau_step: int = .03, tau_tol=0.03, **kwargs):
+ resume=None, live_output: str = None, live_output_options: dict = {}, tau_step: int = .03, tau_tol=0.03, integrator_options: "dict[str, float]" = None, **kwargs):
+
+ """
+ :param model: The model on which the solver will operate. (Deprecated)
+ :type model: gillespy2.Model
+
+ :param t: End time of simulation.
+ :type t: int
+
+ :param number_of_trajectories: Number of trajectories to simulate. By default number_of_trajectories = 1.
+ :type number_of_trajectories: int
+
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :param increment: Time step increment for plotting.
+ :type increment: float
+
+ :param seed: The random seed for the simulation. Optional, defaults to None.
+ :type seed: int
+
+ :param variables: Dictionary of species and their data that will override existing species data.
+ :type variables: dict
+
+ :param resume: Result of a previously run simulation, to be resumed.
+ :type resume: gillespy2.Results
+
+ :param live_output: The type of output to be displayed by solver. Can be "progress", "text", or "graph".
+ :type live_output: str
+
+ :param live_output_options: dictionary contains options for live_output. By default {"interval":1}.
+ "interval" specifies seconds between displaying.
+ "clear_output" specifies if display should be refreshed with each display.
+ :type live_output_options: dict
+
+ :param tau_tol: Tolerance level for Tau leaping algorithm. Larger tolerance values will
+ result in larger tau steps. Default value is 0.03.
+ :type tau_tol: float
+
+ :returns: A result object containing the results of the simulation.
+ :rtype: gillespy2.Results
+ """
from gillespy2 import log
@@ -302,7 +369,7 @@ Source code for gillespy2.solvers.cpp.tau_hybrid_c_solver
raise SimulationError("A model is required to run the simulation.")
self._set_model(model=model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
@@ -339,6 +406,9 @@ Source code for gillespy2.solvers.cpp.tau_hybrid_c_solver
"init_pop": populations,
"parameters": parameter_values
})
+ if integrator_options is not None:
+ integrator_options = TauHybridCSolver.validate_integrator_options(integrator_options)
+ args.update(integrator_options)
seed = self._validate_seed(seed)
if seed is not None:
diff --git a/docs/build/html/_modules/gillespy2/solvers/cpp/tau_leaping_c_solver.html b/docs/build/html/_modules/gillespy2/solvers/cpp/tau_leaping_c_solver.html
index bda52b604..78fc782b6 100644
--- a/docs/build/html/_modules/gillespy2/solvers/cpp/tau_leaping_c_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/cpp/tau_leaping_c_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.cpp.tau_leaping_c_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.tau_leaping_c_solver — GillesPy2 1.6.10 documentation
@@ -126,12 +126,22 @@ Source code for gillespy2.solvers.cpp.tau_leaping_c_solver
from .c_solver import CSolver, SimulationReturnCode
[docs]class TauLeapingCSolver(GillesPySolver, CSolver):
+
+ """
+ A Tau Leaping solver for GillesPy2 models. This solver uses an algorithm that calculates
+ multiple reactions in a single step over a given tau step size. The change in propensities
+ over this step are bounded by relative change in state, yielding greatly improved
+ run-time performance with very little trade-off in accuracy.
+ """
+
name = "TauLeapingCSolver"
target = "tau_leap"
[docs] def get_solver_settings(self):
"""
+ Returns a list of arguments supported by tau_leaping_c_solver.run.
:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'timeout', 'increment', 'seed', 'debug', 'profile')
@@ -139,6 +149,47 @@ Source code for gillespy2.solvers.cpp.tau_leaping_c_solver
increment: int = None, seed: int = None, debug: bool = False, profile: bool = False, variables={},
resume=None, live_output: str = None, live_output_options: dict = {}, tau_tol=0.03, **kwargs):
+ """
+ :param model: The model on which the solver will operate. (Deprecated)
+ :type model: gillespy2.Model
+
+ :param t: End time of simulation.
+ :type t: int
+
+ :param number_of_trajectories: Number of trajectories to simulate. By default number_of_trajectories = 1.
+ :type number_of_trajectories: int
+
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :param increment: Time step increment for plotting.
+ :type increment: float
+
+ :param seed: The random seed for the simulation. Optional, defaults to None.
+ :type seed: int
+
+ :param variables: Dictionary of species and their data that will override existing species data.
+ :type variables: dict
+
+ :param resume: Result of a previously run simulation, to be resumed.
+ :type resume: gillespy2.Results
+
+ :param live_output: The type of output to be displayed by solver. Can be "progress", "text", or "graph".
+ :type live_output: str
+
+ :param live_output_options: dictionary contains options for live_output. By default {"interval":1}.
+ "interval" specifies seconds between displaying.
+ "clear_output" specifies if display should be refreshed with each display.
+ :type live_output_options: dict
+
+ :param tau_tol: Tolerance level for Tau leaping algorithm. Larger tolerance values will
+ result in larger tau steps. Default value is 0.03.
+ :type tau_tol: float
+
+ :returns: A result object containing the results of the simulation
+ :rtype: gillespy2.Results
+ """
+
if self is None:
# Post deprecation block
# raise SimulationError("TauLeapingCSolver must be instantiated to run the simulation")
@@ -161,7 +212,7 @@ Source code for gillespy2.solvers.cpp.tau_leaping_c_solver
raise SimulationError("A model is required to run the simulation.")
self._set_model(model=model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
diff --git a/docs/build/html/_modules/gillespy2/solvers/numpy/CLE_solver.html b/docs/build/html/_modules/gillespy2/solvers/numpy/CLE_solver.html
index 1086821be..4366db43c 100644
--- a/docs/build/html/_modules/gillespy2/solvers/numpy/CLE_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/numpy/CLE_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.numpy.CLE_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.numpy.CLE_solver — GillesPy2 1.6.10 documentation
@@ -124,19 +124,21 @@ Source code for gillespy2.solvers.numpy.CLE_solver
import numpy as np
from gillespy2.solvers.utilities import Tau
from gillespy2.solvers.utilities import solverutils as nputils
-from gillespy2.core import GillesPySolver, log, liveGraphing
+from gillespy2.core import GillesPySolver, log, liveGraphing, SimulationError
from gillespy2.core import ModelError, ExecutionError
from gillespy2.core.results import Results
+
[docs]class CLESolver(GillesPySolver):
"""
A Chemical Langevin Equation Solver for GillesPy2 models.
- TODO: fix
- This solver uses an algorithm calculates
- multiple reactions in a single step over a given tau step size. The change in propensities
- over this step are bounded by bounding the relative change in state, yielding greatly improved
- run-time performance with very little trade-off in accuracy.
+ This solver uses an algorithm that calculates multiple reactions in a single step over a given
+ tau step size. The change in propensities over this step are bounded by bounding the relative
+ change in state, yielding greatly improved run-time performance with very little trade-off in accuracy.
+
+ :param model: The model on which the solver will operate.
+ :type model: gillespy2.Model
"""
name = "CLESolver"
@@ -145,7 +147,7 @@ Source code for gillespy2.solvers.numpy.CLE_solver
pause_event = None
result = None
- def __init__(self, model=None, debug=False, profile=False):
+ def __init__(self, model=None, debug=False):
if model is None:
raise SimulationError("A model is required to run the simulation.")
@@ -156,7 +158,6 @@ Source code for gillespy2.solvers.numpy.CLE_solver
result = None
self.model = model
self.debug = debug
- self.profile = profile
self.is_instantiated = True
def __get_reactions(self, step, curr_state, curr_time, save_time, propensities, reactions):
@@ -202,11 +203,13 @@ Source code for gillespy2.solvers.numpy.CLE_solver
[docs] @classmethod
def get_solver_settings(self):
"""
+ Returns a list of arguments supported by CLE_solver.run.
:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'increment', 'seed', 'debug', 'profile','timeout', 'tau_tol')
-[docs] def run(self=None, model=None, t=20, number_of_trajectories=1, increment=None, seed=None,
+[docs] def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None, seed=None,
debug=False, profile=False, live_output=None, live_output_options={},
timeout=None, resume=None, tau_tol=0.03, **kwargs):
"""
@@ -215,22 +218,23 @@ Source code for gillespy2.solvers.numpy.CLE_solver
and will inherit those parameters which are passed with the model
as the arguments this run function.
- :param model: GillesPy2 model object to simulate
+ :param model: The model on which the solver will operate. (Deprecated)
:type model: gillespy2.Model
- :param t: Simulation run time
- :type t: int
+ :param t: Simulation run time.
+ :type t: int or float
- :param number_of_trajectories: Number of trajectories to simulate
+ :param number_of_trajectories: The number of times to sample the chemical master equation. Each
+ trajectory will be returned at the end of the simulation. By default number_of_trajectories = 1.
:type number_of_trajectories: int
- :param increment: Save point increment for recording data
+ :param increment: Save point increment for recording data.
:type increment: float
- :param seed: The random seed for the simulation. Optional, defaults to None
+ :param seed: The random seed for the simulation. Optional, defaults to None.
:type seed: int
- :param debug: Set to True to provide additional debug information about the simulation
+ :param debug: Set to True to provide additional debug information about the simulation.
:type debug: bool
:param profile: Set to True to provide information about step size (tau) taken at each step.
@@ -239,17 +243,23 @@ Source code for gillespy2.solvers.numpy.CLE_solver
:param live_output: The type of output to be displayed by solver. Can be "progress", "text", or "graph".
:type live_output: str
- :param live_output_options: COntains options for live_output. By default {"interval":1}. "interval"
+ :param live_output_options: Contains options for live_output. By default {"interval":1}. "interval"
specifies seconds between displaying. "clear_output" specifies if display should be refreshed with each
display.
:type live_output_options: dict
- :param timeout:
- :param resume:
- :param tau_tol:
- :param kwargs:
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :param resume: Result of a previously run simulation, to be resumed.
+ :type resume: gillespy2.Results
+
+ :param tau_tol: Tolerance level for Tau leaping algorithm. Larger tolerance values will
+ result in larger tau steps. Default value is 0.03.
+ :type tau_tol: float
- :returns:
+ :returns: A result object containing the results of the simulation.
+ :rtype: gillespy2.Results
"""
from gillespy2 import log
@@ -275,7 +285,7 @@ Source code for gillespy2.solvers.numpy.CLE_solver
raise SimulationError("A model is required to run the simulation.")
self.model = copy.deepcopy(model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
@@ -382,7 +392,7 @@ Source code for gillespy2.solvers.numpy.CLE_solver
return Results.build_from_solver_results(self, live_output_options)
def ___run(self, curr_state,total_time, timeline, trajectory_base, tmpSpecies, live_grapher, t=20,
- number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False, show_labels=True,
+ number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False,
timeout=None, resume=None, tau_tol=0.03, **kwargs):
try:
diff --git a/docs/build/html/_modules/gillespy2/solvers/numpy/ode_solver.html b/docs/build/html/_modules/gillespy2/solvers/numpy/ode_solver.html
index c5ea6be20..2a8c5ae8f 100644
--- a/docs/build/html/_modules/gillespy2/solvers/numpy/ode_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/numpy/ode_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.numpy.ode_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.numpy.ode_solver — GillesPy2 1.6.10 documentation
@@ -130,7 +130,11 @@ Source code for gillespy2.solvers.numpy.ode_solver
[docs]class ODESolver(GillesPySolver):
"""
- This Solver produces the deterministic continuous solution via ODE.
+ This solver produces the deterministic continuous solution via Ordinary Differential Equations.
+ Uses integrators from scipy.integrate.ode to perform calculations used to produce solutions.
+
+ :param model: The model on which the solver will operate.
+ :type model: gillespy2.Model
"""
name = "ODESolver"
rc = 0
@@ -181,35 +185,55 @@ Source code for gillespy2.solvers.numpy.ode_solver
[docs] @classmethod
def get_solver_settings(self):
"""
+ Returns a list of arguments supported by ode_solver.run.
:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'increment', 'integrator', 'integrator_options',
'timeout')
-[docs] def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None, show_labels=True, integrator='lsoda',
+[docs] def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None, integrator='lsoda',
integrator_options={}, live_output=None, live_output_options={}, timeout=None, resume=None, **kwargs):
"""
- :param model: gillespy2.model class object
- :param t: end time of simulation
- :param number_of_trajectories: Should be 1.
- This is deterministic and will always have same results
- :param increment: time step increment for plotting
- :param integrator: integrator to be used form scipy.integrate.ode. Options include 'vode', 'zvode', 'lsoda',
+ :param model: The model on which the solver will operate. (Deprecated)
+ :type model: gillespy2.Model
+
+ :param t: End time of simulation.
+ :type t: int or float
+
+ :param number_of_trajectories: Number of trajectories to simulate. By default number_of_trajectories = 1.
+ This is deterministic and will always have same results.
+ :type number_of_trajectories: int
+
+ :param increment: Time step increment for plotting.
+ :type increment: float
+
+ :param integrator: integrator to be used from scipy.integrate.ode. Options include 'vode', 'zvode', 'lsoda',
'dopri5', and 'dop853'. For more details,
see https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.ode.html
+ :type integrator: str
:param integrator_options: a dictionary containing options to the scipy integrator. for a list of options,
see https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.ode.html.
Example use: {max_step : 0, rtol : .01}
-
- :param timeout: If set, if simulation takes longer than timeout, will exit.
- :type timeout: int
-
- :param resume: Result of a previously run simulation, to be resumed
- :param live_output: str The type of output to be displayed by solver. Can be "progress", "text", or "graph".
+ :type integrator_options: dict
+
+ :param live_output: The type of output to be displayed by solver. Can be "progress", "text", or "graph".
+ :type live_output: str
+
:param live_output_options: dictionary contains options for live_output. By default {"interval":1}.
"interval" specifies seconds between displaying.
- "clear_output" specifies if display should be refreshed with each displa
+ "clear_output" specifies if display should be refreshed with each display.
+ :type live_output_options: dict
+
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :param resume: Result of a previously run simulation, to be resumed.
+ :type resume: gillespy2.Results
+
+ :returns: A result object containing the results of the simulation.
+ :rtype: gillespy2.Results
"""
from gillespy2 import log
@@ -235,7 +259,7 @@ Source code for gillespy2.solvers.numpy.ode_solver
raise SimulationError("A model is required to run the simulation.")
self.model = copy.deepcopy(model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
@@ -282,7 +306,6 @@ Source code for gillespy2.solvers.numpy.ode_solver
'number_of_trajectories':
number_of_trajectories,
'increment': increment,
- 'timeout': timeout,
'resume': resume,
'integrator': integrator,
'integrator_options':
@@ -338,11 +361,11 @@ Source code for gillespy2.solvers.numpy.ode_solver
return Results.build_from_solver_results(self, live_output_options)
def ___run(self, curr_state, curr_time, timeline, trajectory_base, tmpSpecies, live_grapher, t=20,
- number_of_trajectories=1, increment=0.05, timeout=None, show_labels=True, integrator='lsoda',
+ number_of_trajectories=1, increment=0.05, integrator='lsoda',
integrator_options={}, resume=None, **kwargs):
try:
self.__run(curr_state, curr_time, timeline, trajectory_base, tmpSpecies, live_grapher, t,
- number_of_trajectories, increment, timeout, show_labels, integrator, integrator_options, resume,
+ number_of_trajectories, increment, integrator, integrator_options, resume,
**kwargs)
except Exception as e:
self.has_raised_exception = e
@@ -350,7 +373,7 @@ Source code for gillespy2.solvers.numpy.ode_solver
return [], -1
def __run(self, curr_state, curr_time, timeline, trajectory_base, tmpSpecies, live_grapher, t=20,
- number_of_trajectories=1, increment=0.05, timeout=None, show_labels=True, integrator='lsoda',
+ number_of_trajectories=1, increment=0.05, integrator='lsoda',
integrator_options={}, resume=None, **kwargs):
timeStopped = 0
diff --git a/docs/build/html/_modules/gillespy2/solvers/numpy/ssa_solver.html b/docs/build/html/_modules/gillespy2/solvers/numpy/ssa_solver.html
index 1a17a86ca..34c376bc8 100644
--- a/docs/build/html/_modules/gillespy2/solvers/numpy/ssa_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/numpy/ssa_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.numpy.ssa_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.numpy.ssa_solver — GillesPy2 1.6.10 documentation
@@ -129,6 +129,14 @@ Source code for gillespy2.solvers.numpy.ssa_solver
[docs]class NumPySSASolver(GillesPySolver):
+
+ """
+ This solver produces simulations of systems via Stochastic Simulation Algorithm.
+
+ :param model: The model on which the solver will operate.
+ :type model: gillespy2.Model
+ """
+
name = "NumPySSASolver"
rc = 0
stop_event = None
@@ -149,31 +157,52 @@ Source code for gillespy2.solvers.numpy.ssa_solver
[docs] def get_solver_settings(self):
"""
+ Returns a list of arguments supported by the ssa_solver.run
:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'increment', 'seed', 'debug', 'timeout')
-[docs] def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None, seed=None, debug=False, show_labels=True,
+[docs] def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None, seed=None, debug=False,
live_output=None, live_output_options={}, timeout=None, resume=None, **kwargs):
"""
- Run the SSA algorithm using a NumPy for storing the data in arrays and generating the timeline.
+ Run the SSA algorithm. Uses a NumPy array for storing results and for generating the timeline.
- :param model: The model on which the solver will operate.
+ :param model: The model on which the solver will operate. (Deprecated)
+ :type model: gillespy2.Model
+
:param t: The end time of the solver.
- :param number_of_trajectories: The number of times to sample the chemical master equation. Each
- trajectory will be returned at the end of the simulation.
+ :type t: int or float
+
+ :param number_of_trajectories: Number of trajectories to simulate. By default number_of_trajectories = 1.
+ :type number_of_trajectories: int
+
:param increment: The time step of the solution.
+ :type increment: float
+
:param seed: The random seed for the simulation. Defaults to None.
- :param debug: Set to True to provide additional debug information about the
- simulation.
- :param resume: Result of a previously run simulation, to be resumed
- :param live_output: str The type of output to be displayed by solver. Can be "progress", "text", or "graph".
+ :type seed: int
+
+ :param debug: Set to True to provide additional debug information about the simulation.
+ :type debug: bool
+
+ :param live_output: The type of output to be displayed by solver. Can be "progress", "text", or "graph".
+ :type live_output: str
+
:param live_output_options: dictionary contains options for live_output. By default {"interval":1}.
"interval" specifies seconds between displaying.
- "clear_output" specifies if display should be refreshed with each display
-
- :returns: a list of each trajectory simulated.
+ "clear_output" specifies if display should be refreshed with each display.
+ :type live_output_options: dict
+
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :param resume: Result of a previously run simulation, to be resumed.
+ :type resume: gillespy2.Results
+
+ :returns: A result object containing the results of the simulation.
+ :rtype: gillespy2.Results
"""
from gillespy2 import log
@@ -199,7 +228,7 @@ Source code for gillespy2.solvers.numpy.ssa_solver
raise SimulationError("A model is required to run the simulation.")
self.model = copy.deepcopy(model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
@@ -246,8 +275,6 @@ Source code for gillespy2.solvers.numpy.ssa_solver
number_of_trajectories,
'increment': increment,
'seed': seed, 'debug': debug,
- 'show_labels': show_labels,
- 'timeout': timeout,
'resume': resume, })
try:
time = 0
@@ -301,20 +328,20 @@ Source code for gillespy2.solvers.numpy.ssa_solver
return Results.build_from_solver_results(self, live_output_options)
def ___run(self, curr_state, total_time, timeline, trajectory_base, live_grapher, t=20,
- number_of_trajectories=1, increment=0.05, seed=None, debug=False, show_labels=True, resume=None,
- timeout=None):
+ number_of_trajectories=1, increment=0.05, seed=None, debug=False, resume=None,
+ ):
try:
self.__run(curr_state, total_time, timeline, trajectory_base, live_grapher, t, number_of_trajectories,
- increment, seed, debug, show_labels, resume, timeout)
+ increment, seed, debug, resume)
except Exception as e:
self.has_raised_exception = e
self.result = []
return [], -1
def __run(self, curr_state, total_time, timeline, trajectory_base, live_grapher, t=20,
- number_of_trajectories=1, increment=0.05, seed=None, debug=False, show_labels=True,
- resume=None, timeout=None):
+ number_of_trajectories=1, increment=0.05, seed=None, debug=False,
+ resume=None,):
# for use with resume, determines how much excess data to cut off due to
# how species and time are initialized to 0
diff --git a/docs/build/html/_modules/gillespy2/solvers/numpy/tau_hybrid_solver.html b/docs/build/html/_modules/gillespy2/solvers/numpy/tau_hybrid_solver.html
index 5f8741a44..1a0593feb 100644
--- a/docs/build/html/_modules/gillespy2/solvers/numpy/tau_hybrid_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/numpy/tau_hybrid_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.numpy.tau_hybrid_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.numpy.tau_hybrid_solver — GillesPy2 1.6.10 documentation
@@ -162,16 +162,20 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
[docs]class TauHybridSolver(GillesPySolver):
"""
- This Solver uses a root-finding interpretation of the direct SSA method,
+ This solver uses a root-finding interpretation of the direct SSA method,
along with ODE solvers to simulate ODE and Stochastic systems
interchangeably or simultaneously.
+ Uses integrators from scipy.integrate.ode to perform calculations used to produce solutions.
+
+ :param model: The model on which the solver will operate.
+ :type model: gillespy2.Model
"""
name = "TauHybridSolver"
rc = 0
result = None
stop_event = None
- def __init__(self, model=None):
+ def __init__(self, model=None, profile_reactions=False):
if model is None:
raise SimulationError("A model is required to run the simulation.")
@@ -179,6 +183,12 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
rc = 0
self.model = copy.deepcopy(model)
self.is_instantiated = True
+ self.profile_reactions = profile_reactions
+ self.profile_data = {}
+ if self.profile_reactions:
+ self.profile_data['time'] = []
+ for k in list(self.model.listOfSpecies)+list(self.model.listOfReactions):
+ self.profile_data[k] = []
def __toggle_reactions(self, all_compiled, deterministic_reactions, dependencies,
curr_state, det_spec, rr_sets):
@@ -193,7 +203,6 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
rate_rules = all_compiled['rules']
rxns = all_compiled['rxns']
-
# If the set has changed, reactivate non-determinsitic reactions
reactivate = []
for r in inactive_reactions:
@@ -202,31 +211,32 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
for r in reactivate:
rxns[r] = inactive_reactions.pop(r, None)
- # floor non-det species
- for s, d in det_spec.items():
- if not d and isinstance(curr_state[s], float):
- curr_state[s] = math.floor(curr_state[s])
-
# Deactivate Determinsitic Reactions
for r in deterministic_reactions:
if not r in inactive_reactions:
inactive_reactions[r] = rxns.pop(r, None)
+ # floor non-det species
+ for s,d in det_spec.items():
+ if not d and isinstance(curr_state[s], float):
+ curr_state[s] = round(curr_state[s])
+
# Check if this reaction set is already compiled and in use:
if deterministic_reactions in rr_sets.keys():
return rr_sets[deterministic_reactions]
else:
# Otherwise, this is a new determinstic reaction set that must be compiled
- return self.__create_diff_eqs(deterministic_reactions,
- dependencies, rr_sets)
+ tmp = self.__create_diff_eqs(deterministic_reactions,
+ dependencies, rr_sets, rate_rules)
+ return tmp
- def __create_diff_eqs(self, comb, dependencies, rr_sets):
+ def __create_diff_eqs(self, comb, dependencies, rr_sets, rate_rules):
"""
Helper method used to convert stochastic reaction descriptions into
differential equations, used dynamically throught the simulation.
"""
diff_eqs = OrderedDict()
- rate_rules = OrderedDict()
+ output_rules = copy.deepcopy(rate_rules);
# Initialize sample dict
rr_vars = {}
@@ -263,9 +273,9 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
del diff_eqs[self.model.listOfSpecies[spec]]
# create a dictionary of compiled gillespy2 rate rules
for spec, rate in diff_eqs.items():
- rate_rules[spec] = compile(gillespy2.RateRule(spec, rate).formula, '<string>', 'eval')
+ output_rules[spec] = compile(gillespy2.RateRule(spec, rate).formula, '<string>', 'eval')
rr_sets[comb] = rate_rules # save values
- return rate_rules
+ return output_rules
def __flag_det_reactions(self, det_spec, det_rxn, dependencies):
"""
@@ -297,14 +307,23 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
deterministic_reactions = frozenset(deterministic_reactions)
return deterministic_reactions
- def __calculate_statistics(self, *switch_args):
+ def __calculate_statistics(self, curr_time, propensities, curr_state, tau_step, det_spec, cv_history={}):
"""
Calculates Mean, Standard Deviation, and Coefficient of Variance for each
dynamic species, then set if species can be represented determistically
+
+ NOTE: the argument cv_history should not be passed in, this is modified by the function
+ to keep a persistent data set.
"""
- propensities, curr_state, tau_step, det_spec = switch_args
+ #TODO: move configuration to solver init
+ history_length = 12 #cite: "Statistical rules of thumb" G Van Belle
+
+ if curr_time==0.0: #re-set cv_history
+ for k in list(cv_history.keys()):
+ del cv_history[k]
CV = OrderedDict()
+ # calculate CV by estimating the next step
mn = {species: curr_state[species] for species, value in
self.model.listOfSpecies.items() if value.mode == 'dynamic'}
sd = {species: 0 for species, value in
@@ -313,26 +332,42 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
for r, rxn in self.model.listOfReactions.items():
for reactant in rxn.reactants:
if reactant.mode == 'dynamic':
- mn[reactant.name] -= (tau_step * propensities[r] * rxn.reactants[reactant])
- sd[reactant.name] += (tau_step * propensities[r] * rxn.reactants[reactant] ** 2)
+ mn[reactant.name] -= (propensities[r] * rxn.reactants[reactant])
+ sd[reactant.name] += (propensities[r] * (rxn.reactants[reactant] ** 2))
for product in rxn.products:
if product.mode == 'dynamic':
- mn[product.name] += (tau_step * propensities[r] * rxn.products[product])
- sd[product.name] += (tau_step * propensities[r] * rxn.products[product] ** 2)
-
- # Get coefficient of variance for each dynamic species
+ mn[product.name] += (propensities[r] * rxn.products[product])
+ sd[product.name] += (propensities[r] * (rxn.products[product] ** 2))
+ # Calcuate the derivative based CV
+ for species,value in self.model.listOfSpecies.items():
+ if value.mode == 'dynamic':
+ if mn[species] > 0 and sd[species] > 0:
+ CV[species] = math.sqrt(sd[species]) / mn[species]
+ else:
+ CV[species] = 1 # value chosen to guarantee species will be discrete
+
+ # Keep a history of the past CV values, calculate a time-averaged value
+ CV_a = OrderedDict() # time-averaged CV (forward derivative based)
+ for species,value in self.model.listOfSpecies.items():
+ if value.mode == 'dynamic':
+ if species not in cv_history:
+ cv_history[species] = []
+ cv_history[species].append(CV[species])
+ if len(cv_history[species]) > history_length:
+ cv_history[species].pop(0) #remove the first item
+ CV_a[species] = sum(cv_history[species])/len(cv_history[species])
+
+ # Select DISCRETE or CONTINOUS mode for each species
for species in mn:
+ prev_det = det_spec[species]
sref = self.model.listOfSpecies[species]
if sref.switch_min == 0:
- if mn[species] > 0:
- CV[species] = sd[species] / mn[species]
- else:
- CV[species] = 1 # value chosen to guarantee discrete
# Set species to deterministic if CV is less than threshhold
- det_spec[species] = CV[species] < sref.switch_tol
+ det_spec[species] = CV_a[species] < sref.switch_tol
else:
det_spec[species] = mn[species] > sref.switch_min
- return sd, CV
+
+ return mn, sd, CV
@staticmethod
def __f(t, y, curr_state, species, reactions, rate_rules, propensities,
@@ -353,7 +388,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
for s, rr in active_rr.items():
try:
state_change[y_map[s.name]] += eval(rr, {**eval_globals, **curr_state})
- except ValueError:
+ except ValueError as e:
pass
for i, r in enumerate(compiled_reactions):
propensities[r] = eval(compiled_reactions[r], {**eval_globals, **curr_state})
@@ -362,7 +397,6 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
triggered = eval(event.trigger.expression, {**eval_globals, **curr_state})
if triggered:
state_change[y_map[event]] = 1
-
return state_change
def __find_event_time(self, sol, start, end, index, depth):
@@ -517,18 +551,27 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
t0_delayed_events[e.name] = execution_time
return t0_delayed_events, species_modified_by_events
- def __update_stochastic_rxn_states(self, compiled_reactions, curr_state):
+ def __update_stochastic_rxn_states(self, compiled_reactions, curr_state, only_update=None):
"""
Helper method for updating the state of stochastic reactions.
+
+ if 'only_update' is set to a reaction name, it will only reset that reaction, and only one firing
"""
+
rxn_count = OrderedDict()
species_modified = OrderedDict()
# Update stochastic reactions
+
for rxn in compiled_reactions:
rxn_count[rxn] = 0
- while curr_state[rxn] > 0:
- rxn_count[rxn] += 1
- curr_state[rxn] += math.log(random.uniform(0, 1))
+ if only_update is not None: # for a single SSA step
+ if rxn == only_update:
+ curr_state[rxn] = math.log(random.uniform(0, 1)) #set this value, needs to be <0
+ rxn_count[rxn] = 1
+ else: # for a normal Tau-step
+ while curr_state[rxn] > 0:
+ rxn_count[rxn] += 1
+ curr_state[rxn] += math.log(random.uniform(0, 1))
if rxn_count[rxn]:
for reactant in self.model.listOfReactions[rxn].reactants:
species_modified[reactant.name] = True
@@ -536,9 +579,9 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
for product in self.model.listOfReactions[rxn].products:
species_modified[product.name] = True
curr_state[product.name] += self.model.listOfReactions[rxn].products[product] * rxn_count[rxn]
- return species_modified
+ return species_modified, rxn_count
- def __integrate(self, integrator, integrator_options, curr_state, y0, curr_time,
+ def __integrate(self, integrator_options, curr_state, y0, curr_time,
propensities, y_map, compiled_reactions,
active_rr, event_queue,
delayed_events, trigger_states,
@@ -582,13 +625,16 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
while sol.t < next_tau:
counter += 1
sol.step()
- # Update states of all species based on changes made to species through
- # ODE processes. This will update all species whose mode is set to
- # 'continuous', as well as 'dynamic' mode species which have been
- # flagged as deterministic.
- for spec_name, species in self.model.listOfSpecies.items():
- if not species.constant:
- curr_state[spec_name] = sol.y[y_map[spec_name]]
+
+
+ # Update states of all species based on changes made to species through
+ # ODE processes. This will update all species whose mode is set to
+ # 'continuous', as well as 'dynamic' mode species which have been
+ # flagged as deterministic.
+
+ for spec_name, species in self.model.listOfSpecies.items():
+ if not species.constant:
+ curr_state[spec_name] = sol.y[y_map[spec_name]]
# Search for precise event times
'''
@@ -648,9 +694,20 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
return sol, curr_time
- def __simulate(self, integrator, integrator_options, curr_state, y0, curr_time,
+
+ def __simulate_invalid_state_check(self, species_modified, curr_state, compiled_reactions):
+ invalid_state = False
+ err_message=""
+ # check each species to see if they are negative
+ for s in species_modified.keys():
+ if curr_state[s] < 0:
+ invalid_state = True
+ err_message += f"'{s}' has negative state '{curr_state[s]}'"
+ return (invalid_state, err_message)
+
+ def __simulate(self, integrator_options, curr_state, y0, curr_time,
propensities, species, parameters, compiled_reactions,
- active_rr, y_map, trajectory, save_times,
+ active_rr, y_map, trajectory, save_times, save_index,
delayed_events, trigger_states, event_sensitivity,
tau_step, pure_ode, debug):
"""
@@ -673,46 +730,113 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
"""
event_queue = []
- prev_y0 = y0.copy()
- prev_curr_state = curr_state.copy()
+ prev_y0 = copy.deepcopy(y0)
+ prev_curr_state = copy.deepcopy(curr_state)
prev_curr_time = curr_time
loop_count = 0
+ invalid_state = False
- while True:
- loop_count += 1
- if loop_count > 100:
- raise Exception("Loop over __integrate() exceeded loop count")
- sol, curr_time = self.__integrate(integrator, integrator_options, curr_state,
- y0, curr_time, propensities, y_map,
- compiled_reactions,
- active_rr,
- event_queue,
- delayed_events,
- trigger_states,
- event_sensitivity,
- tau_step,
- pure_ode)
-
- species_modified = self.__update_stochastic_rxn_states(compiled_reactions, curr_state)
-
- # Occasionally, a tau step can result in an overly-aggressive
- # forward step and cause a species population to fall below 0,
- # which would result in an erroneous simulation. If this occurs,
- # back simulation up one step and attempt forward simulation using
- # a smaller tau step.
- neg_state = False
- for s in species_modified.keys():
- if curr_state[s] < 0:
- neg_state = True
- if neg_state:
- y0 = prev_y0.copy()
- curr_state = prev_curr_state.copy()
- curr_time = prev_curr_time
- tau_step = tau_step / 2
- else:
- break
-
- # Now update the step and trajectories for this step of the simulation.
+
+ starting_curr_state = copy.deepcopy(curr_state)
+ starting_propensities = copy.deepcopy(propensities)
+ starting_tau_step=tau_step
+ species_modified=None
+ rxn_count=None
+ loop_err_message=""
+ if self.profile_reactions:
+ self.profile_data['time'].append(curr_time)
+ for k in list(self.model.listOfSpecies)+list(self.model.listOfReactions):
+ self.profile_data[k].append(curr_state[k])
+
+
+ # check each reaction to see if it is >=0. If we have taken a single SSA step, this could be >0 for the non-selected reactions, check if propensity is zero and reset if so
+ for r in compiled_reactions.keys():
+ if curr_state[r] >= 0 and propensities[r] == 0:
+ curr_state[r] = math.log(random.uniform(0, 1))
+
+
+ sol, curr_time = self.__integrate(integrator_options, curr_state,
+ y0, curr_time, propensities, y_map,
+ compiled_reactions,
+ active_rr,
+ event_queue,
+ delayed_events,
+ trigger_states,
+ event_sensitivity,
+ tau_step,
+ pure_ode)
+
+ species_modified,rxn_count = self.__update_stochastic_rxn_states(compiled_reactions, curr_state)
+
+ # Occasionally, a tau step can result in an overly-aggressive
+ # forward step and cause a species population to fall below 0,
+ # which would result in an erroneous simulation.
+ # We estimate the time to the first
+ # stochatic reaction firing (assume constant propensities) and
+ # simulate the ODE system until that time, fire that reaction
+ # and continue the simulation.
+ (invalid_state, invalid_err_message) = self.__simulate_invalid_state_check(species_modified, curr_state, compiled_reactions)
+
+ if invalid_state:
+ invalid_state = False
+ # Redo this step, with a smaller Tau such that a single SSA reaction occurs
+ y0 = copy.deepcopy(prev_y0)
+ curr_state_after = copy.deepcopy(curr_state)
+ curr_state = copy.deepcopy(prev_curr_state)
+ floored_curr_state = copy.deepcopy(prev_curr_state)
+ propensities_after = copy.deepcopy(propensities)
+ propensities = copy.deepcopy(starting_propensities)
+ floored_propensities = copy.deepcopy(starting_propensities)
+ curr_time = prev_curr_time
+
+ # floored propensites
+ for i, s in enumerate(self.model.listOfSpecies):
+ floored_curr_state[s] = math.floor(floored_curr_state[s])
+ saved_curr_state = copy.deepcopy(curr_state)
+ curr_state = floored_curr_state
+ for i, r in enumerate(compiled_reactions):
+ try:
+ floored_propensities[r] = eval(compiled_reactions[r], {**eval_globals, **curr_state})
+ except Exception as e:
+ raise SimulationError('Error calculation propensity for {0}.\nReason: {1}\nfloored_propensities={2}\ncompiled_reactions={3}'.format(r, e, floored_propensities,compiled_reactions))
+ curr_state = saved_curr_state
+
+ rxn_times = OrderedDict()
+ min_tau = None
+ rxn_selected = None
+ for rname,rcnt in rxn_count.items():
+ if floored_propensities[rname] > 0.0:
+ # estimate the zero crossing time
+ rxn_times[rname] = -1* curr_state[rname] / propensities[rname]
+ if min_tau is None or min_tau > rxn_times[rname]:
+ min_tau = rxn_times[rname]
+ rxn_selected = rname
+ if rxn_selected is None: raise Exception(f"Negative State detected in step, and no reaction found to fire.\n\n error_message={invalid_err_message}\n curr_time={curr_time}\n tau_step={tau_step}\n curr_state={curr_state}\n\nstarting_curr_state={starting_curr_state}\n\n starting_tau_step={starting_tau_step}\nspecies_modified={species_modified}\nrxn_count={rxn_count}\n propensities={propensities}\nrxn_times={rxn_times}\ncompiled_reactions={compiled_reactions}\ncurr_state_after={curr_state_after}\n propensities_after={propensities_after}\nstarting_propensities={starting_propensities}\nfloored_curr_state={floored_curr_state}\nfloored_propensities={floored_propensities}\n ")
+
+ tau_step = min_tau #estimated time to the first stochatic reaction
+
+ sol, curr_time = self.__integrate(integrator_options, curr_state,
+ y0, curr_time, propensities, y_map,
+ compiled_reactions,
+ active_rr,
+ event_queue,
+ delayed_events,
+ trigger_states,
+ event_sensitivity,
+ tau_step,
+ pure_ode)
+
+ # only update the selected reaction
+ first_rxn_count = copy.deepcopy(rxn_count)
+ first_err_message = invalid_err_message
+ species_modified,rxn_count = self.__update_stochastic_rxn_states(compiled_reactions, curr_state, only_update=rxn_selected)
+
+ (invalid_state, invalid_err_message) = self.__simulate_invalid_state_check(species_modified, curr_state, compiled_reactions)
+ if invalid_state:
+ raise Exception(f"Negative State detected in step, after single SSA step.\n\n error_message={invalid_err_message}\n curr_time={curr_time}\n tau_step={tau_step}\n curr_state={curr_state}\n\nstarting_curr_state={starting_curr_state}\n\n starting_tau_step={starting_tau_step}\nspecies_modified={species_modified}\nrxn_count={rxn_count}\n propensities={propensities}\nrxn_selected={rxn_selected}\ncompiled_reactions={compiled_reactions}\ncurr_state_after={curr_state_after} \n propensities_after={propensities_after}\nstarting_propensities={starting_propensities}\nfirst_rxn_count={first_rxn_count}\n first_err_message={first_err_message}\n 2nd_tau_step={tau_step}\nfloored_propensities={floored_propensities} ")
+
+
+ # Now update the step and trajectories for this step of the simulation.
# Here we make our final assignments for this step, and begin
# populating our results trajectory.
num_saves = 0
@@ -720,8 +844,8 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
if time > curr_time:
break
# if a solution is given for it
- trajectory_index = np.where(self.model.tspan == time)[0][0]
- assignment_state = curr_state.copy()
+ trajectory_index = save_index
+ assignment_state = copy.deepcopy(curr_state)
for s in range(len(species)):
# Get ODE Solutions
trajectory[trajectory_index][s + 1] = sol.y[s]
@@ -733,8 +857,9 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
for ar in self.model.listOfAssignmentRules.values():
assignment_value = eval(ar.formula, {**eval_globals, **assignment_state})
assignment_state[ar.variable] = assignment_value
- trajectory[trajectory_index][species.index(ar.variable) + 1] = assignment_value
+ trajectory[trajectory_index][species.index(ar.variable.name) + 1] = assignment_value
num_saves += 1
+ save_index += 1
save_times = save_times[num_saves:] # remove completed save times
events_processed = self.__process_queued_events(event_queue, trigger_states, curr_state)
@@ -756,7 +881,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
events_processed = self.__process_queued_events(event_queue, trigger_states, curr_state)
- return sol, curr_state, curr_time, save_times
+ return sol, curr_state, curr_time, save_times, save_index
def __set_seed(self, seed):
# Set seed if supplied
@@ -789,6 +914,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
for i, r in enumerate(self.model.listOfReactions):
compiled_reactions[r] = compile(self.model.listOfReactions[r].propensity_function, '<string>',
'eval')
+
compiled_rate_rules = OrderedDict()
for i, rr in enumerate(self.model.listOfRateRules.values()):
if isinstance(rr.variable, str):
@@ -798,7 +924,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
compiled_rate_rules[rr.variable] = compile(rr.formula, '<string>', 'eval')
compiled_inactive_reactions = OrderedDict()
- compiled_propensities = compiled_reactions.copy()
+ compiled_propensities = copy.deepcopy(compiled_reactions)
return compiled_reactions, compiled_rate_rules, compiled_inactive_reactions, compiled_propensities
@@ -864,10 +990,12 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
[docs] @classmethod
def get_solver_settings(self):
"""
+ Returns a list of arguments supported by tau_hybrid_solver.run.
:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'increment', 'seed', 'debug', 'profile', 'tau_tol',
- 'event_sensitivity', 'integrator', 'integrator_options', 'timeout')
+ 'event_sensitivity', 'integrator_options', 'timeout')
[docs] @classmethod
def get_supported_features(cls):
@@ -879,24 +1007,22 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
}
[docs] def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None, seed=None,
- debug=False, profile=False, tau_tol=0.03, event_sensitivity=100, integrator='LSODA',
- integrator_options={}, live_output=None, live_output_options={}, timeout=None, **kwargs):
+ debug=False, profile=False, tau_tol=0.03, event_sensitivity=100,integrator_options={},
+ live_output=None, live_output_options={}, timeout=None, **kwargs):
"""
Function calling simulation of the model. This is typically called by the run function in GillesPy2 model
objects and will inherit those parameters which are passed with the model as the arguments this run function.
- :param model: GillesPy2 model object to simulate
- :type model: GillesPy2.model
+ :param model: The model on which the solver will operate. (Deprecated)
+ :type model: gillespy2.Model
- :param t: Simulation run time
- :type t: int
+ :param t: Simulation run time.
+ :type t: int or float
- :param number_of_trajectories: The number of times to sample the chemical master equation. Each
- trajectory will be returned at the end of the simulation.
- Optional, defaults to 1. Number of trajectories to simulate
+ :param number_of_trajectories: Number of trajectories to simulate. By default number_of_trajectories = 1.
:type number_of_trajectories: int
- :param increment: Save point increment for recording data
+ :param increment: Save point increment for recording data.
:type increment: float
:param seed: The random seed for the simulation. Optional, defaults to None.
@@ -909,11 +1035,11 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
:type profile: bool
:param tau_tol: Tolerance level for Tau leaping algorithm. Larger tolerance values will
- result in larger tau steps. Default value is 0.03.
+ result in larger tau steps. Default value is 0.03.
:type tau_tol: float
:param event_sensitivity: Number of data points to be inspected between integration
- steps/save points for event detection
+ steps/save points for event detection. Default event_sensitivity = 100
:type event_sensitivity: int
:param integrator_options: contains options to the scipy integrator. by default, this includes
@@ -928,7 +1054,13 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
:param live_output_options: contains options for live_output. By default {"interval":1}.
"interval" specifies seconds between displaying.
"clear_output" specifies if display should be refreshed with each display
- :type live_output_options: str
+ :type live_output_options: dict
+
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :returns: A result object containing the results of the simulation.
+ :rtype: gillespy2.Results
"""
from gillespy2 import log
@@ -954,7 +1086,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
raise SimulationError("A model is required to run the simulation.")
self.model = copy.deepcopy(model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
@@ -1034,9 +1166,8 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
'number_of_trajectories': number_of_trajectories,
'increment': increment, 'seed': seed,
'debug': debug, 'profile': profile,
- 'timeout': timeout, 'tau_tol': tau_tol,
+ 'tau_tol': tau_tol,
'event_sensitivity': event_sensitivity,
- 'integrator': integrator,
'integrator_options': integrator_options})
try:
sim_thread.start()
@@ -1080,12 +1211,12 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
def ___run(self, curr_state, curr_time, timeline, trajectory_base, initial_state, live_grapher, t=20,
number_of_trajectories=1, increment=0.05, seed=None,
- debug=False, profile=False, tau_tol=0.03, event_sensitivity=100, integrator='LSODA',
+ debug=False, profile=False, tau_tol=0.03, event_sensitivity=100,
integrator_options={}, **kwargs):
try:
self.__run(curr_state, curr_time, timeline, trajectory_base, initial_state, live_grapher, t,
number_of_trajectories, increment, seed, debug,
- profile, tau_tol, event_sensitivity, integrator,
+ profile, tau_tol, event_sensitivity,
integrator_options, **kwargs)
except Exception as e:
self.has_raised_exception = e
@@ -1095,7 +1226,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
def __run(self, curr_state, curr_time, timeline, trajectory_base, initial_state, live_grapher, t=20,
number_of_trajectories=1, increment=0.05, seed=None,
debug=False, profile=False,
- tau_tol=0.03, event_sensitivity=100, integrator='LSODA',
+ tau_tol=0.03, event_sensitivity=100,
integrator_options={}, **kwargs):
# create mapping of species dictionary to array indices
@@ -1121,10 +1252,6 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
if spec.mode != 'continuous':
pure_ode = False
- if debug:
- print('dependencies')
- print(dependencies)
-
simulation_data = []
dependencies = OrderedDict()
@@ -1160,6 +1287,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
data = OrderedDict() # Dictionary for results
data['time'] = timeline # All time entries
save_times = timeline
+ save_index = 0
# Record Highest Order reactant for each reaction and set error tolerance
if not pure_ode:
@@ -1199,8 +1327,11 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
for i, r in enumerate(self.model.listOfReactions):
try:
propensities[r] = eval(compiled_propensities[r], eval_globals, curr_state[0])
+ if curr_state[0][r] > 0 and propensities[r]==0:
+ # This is an edge case, that might happen after a single SSA step.
+ curr_state[0][r] = math.log(random.uniform(0, 1))
except Exception as e:
- raise SimulationError('Error calculation propensity for {0}.\nReason: {1}'.format(r, e))
+ raise SimulationError('Error calculation propensity for {0}.\nReason: {1}\ncurr_state={2}'.format(r, e, curr_state))
# Calculate Tau statistics and select a good tau step
if not pure_ode:
@@ -1210,8 +1341,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
# Process switching if used
if not pure_stochastic and not pure_ode:
- switch_args = [propensities, curr_state[0], tau_step, det_spec]
- sd, CV = self.__calculate_statistics(*switch_args)
+ mn, sd, CV = self.__calculate_statistics(curr_time[0], propensities, curr_state[0], tau_step, det_spec)
# Calculate sd and CV for hybrid switching and flag deterministic reactions
if pure_stochastic:
@@ -1220,7 +1350,7 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
deterministic_reactions = self.__flag_det_reactions(det_spec, det_rxn, dependencies)
if debug:
- print('mean: {0}'.format(mu_i))
+ print('mean: {0}'.format(mn))
print('standard deviation: {0}'.format(sd))
print('CV: {0}'.format(CV))
print('det_spec: {0}'.format(det_spec))
@@ -1239,12 +1369,13 @@ Source code for gillespy2.solvers.numpy.tau_hybrid_solver
compiled_reactions, self.model.listOfEvents, curr_state[0])
# Run simulation to next step
- sol, curr_state[0], curr_time[0], save_times = self.__simulate(integrator, integrator_options,
+ sol, curr_state[0], curr_time[0], save_times, save_index = self.__simulate(integrator_options,
curr_state[0], y0, curr_time[0],
propensities, species,
parameters, compiled_reactions,
active_rr, y_map,
- trajectory, save_times, delayed_events,
+ trajectory, save_times, save_index,
+ delayed_events,
trigger_states,
event_sensitivity, tau_step, pure_ode,
debug)
diff --git a/docs/build/html/_modules/gillespy2/solvers/numpy/tau_leaping_solver.html b/docs/build/html/_modules/gillespy2/solvers/numpy/tau_leaping_solver.html
index f070e4c83..4ef56b821 100644
--- a/docs/build/html/_modules/gillespy2/solvers/numpy/tau_leaping_solver.html
+++ b/docs/build/html/_modules/gillespy2/solvers/numpy/tau_leaping_solver.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.numpy.tau_leaping_solver — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.numpy.tau_leaping_solver — GillesPy2 1.6.10 documentation
@@ -130,10 +130,13 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
[docs]class TauLeapingSolver(GillesPySolver):
"""
- A Tau Leaping Solver for GillesPy2 models. This solver uses an algorithm calculates
+ A Tau Leaping solver for GillesPy2 models. This solver uses an algorithm that calculates
multiple reactions in a single step over a given tau step size. The change in propensities
over this step are bounded by bounding the relative change in state, yielding greatly improved
run-time performance with very little trade-off in accuracy.
+
+ :param model: The model on which the solver will operate.
+ :type model: gillespy2.Model
"""
name = "TauLeapingSolver"
@@ -142,7 +145,7 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
pause_event = None
result = None
- def __init__(self, model=None, debug=False, profile=False):
+ def __init__(self, model=None, debug=False):
if model is None:
raise SimulationError("A model is required to run the simulation.")
@@ -153,7 +156,6 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
result = None
self.model = copy.deepcopy(model)
self.debug = debug
- self.profile = profile
self.is_instantiated = True
def __get_reactions(self, step, curr_state, curr_time, save_time, propensities, reactions):
@@ -189,7 +191,9 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
[docs] @classmethod
def get_solver_settings(self):
"""
+ Returns a list of arguments supported by tau_leaping_solver.run.
:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+ :rtype: tuple
"""
return ('model', 't', 'number_of_trajectories', 'increment', 'seed', 'debug', 'profile','timeout', 'tau_tol')
@@ -202,22 +206,22 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
and will inherit those parameters which are passed with the model
as the arguments this run function.
- :param model: GillesPy2 model object to simulate
+ :param model: The model on which the solver will operate. (Deprecated)
:type model: gillespy2.Model
- :param t: Simulation run time
- :type t: int
+ :param t: Simulation run time.
+ :type t: int or float
- :param number_of_trajectories: Number of trajectories to simulate
+ :param number_of_trajectories: Number of trajectories to simulate. By default number_of_trajectories = 1.
:type number_of_trajectories: int
- :param increment: Save point increment for recording data
+ :param increment: Save point increment for recording data.
:type increment: float
- :param seed: The random seed for the simulation. Optional, defaults to None
+ :param seed: The random seed for the simulation. Optional, defaults to None.
:type seed: int
- :param debug: Set to True to provide additional debug information about the simulation
+ :param debug: Set to True to provide additional debug information about the simulation.
:type debug: bool
:param profile: Set to True to provide information about step size (tau) taken at each step.
@@ -226,17 +230,23 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
:param live_output: The type of output to be displayed by solver. Can be "progress", "text", or "graph".
:type live_output: str
- :param live_output_options: COntains options for live_output. By default {"interval":1}. "interval"
+ :param live_output_options: Contains options for live_output. By default {"interval":1}. "interval"
specifies seconds between displaying. "clear_output" specifies if display should be refreshed with each
display.
:type live_output_options: dict
- :param timeout:
- :param resume:
- :param tau_tol:
- :param kwargs:
+ :param timeout: If set, if simulation takes longer than timeout, will exit.
+ :type timeout: int
+
+ :param resume: Result of a previously run simulation, to be resumed.
+ :type resume: gillespy2.Results
- :returns:
+ :param tau_tol: Tolerance level for Tau leaping algorithm. Larger tolerance values will
+ result in larger tau steps. Default value is 0.03.
+ :type tau_tol: float
+
+ :returns: A result object containing the results of the simulation.
+ :rtype: gillespy2.Results
"""
from gillespy2 import log
@@ -262,7 +272,7 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
raise SimulationError("A model is required to run the simulation.")
self.model = copy.deepcopy(model)
- self.model.resolve_parameters()
+ self.model.compile_prep()
self.validate_model(self.model, model)
self.validate_sbml_features(model=self.model)
@@ -369,12 +379,12 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
return Results.build_from_solver_results(self, live_output_options)
def ___run(self, curr_state,total_time, timeline, trajectory_base, tmpSpecies, live_grapher, t=20,
- number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False, show_labels=True,
- timeout=None, resume=None, tau_tol=0.03, **kwargs):
+ number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False,
+ resume=None, tau_tol=0.03, **kwargs):
try:
self.__run(curr_state, total_time, timeline, trajectory_base, tmpSpecies, live_grapher, t, number_of_trajectories,
- increment, seed, debug, profile, timeout, resume, tau_tol, **kwargs)
+ increment, seed, debug, profile, resume, tau_tol, **kwargs)
except Exception as e:
self.has_raised_exception = e
@@ -382,7 +392,7 @@ Source code for gillespy2.solvers.numpy.tau_leaping_solver
return [], -1
def __run(self, curr_state, total_time, timeline, trajectory_base, tmpSpecies, live_grapher, t=20,
- number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False, timeout=None,
+ number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False,
resume=None, tau_tol=0.03, **kwargs):
# for use with resume, determines how much excess data to cut off due to
diff --git a/docs/build/html/_modules/gillespy2/solvers/stochkit/stochkit_solvers.html b/docs/build/html/_modules/gillespy2/solvers/stochkit/stochkit_solvers.html
index 9b1b802fe..bb7193ecb 100644
--- a/docs/build/html/_modules/gillespy2/solvers/stochkit/stochkit_solvers.html
+++ b/docs/build/html/_modules/gillespy2/solvers/stochkit/stochkit_solvers.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.stochkit.stochkit_solvers — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.stochkit.stochkit_solvers — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/solvers/utilities/Tau.html b/docs/build/html/_modules/gillespy2/solvers/utilities/Tau.html
index b7f477985..b122e4cf4 100644
--- a/docs/build/html/_modules/gillespy2/solvers/utilities/Tau.html
+++ b/docs/build/html/_modules/gillespy2/solvers/utilities/Tau.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.utilities.Tau — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.utilities.Tau — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/solvers/utilities/cpp_support_test.html b/docs/build/html/_modules/gillespy2/solvers/utilities/cpp_support_test.html
index aba7c2c87..cc872e6c7 100644
--- a/docs/build/html/_modules/gillespy2/solvers/utilities/cpp_support_test.html
+++ b/docs/build/html/_modules/gillespy2/solvers/utilities/cpp_support_test.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.utilities.cpp_support_test — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.utilities.cpp_support_test — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/solvers/utilities/solverutils.html b/docs/build/html/_modules/gillespy2/solvers/utilities/solverutils.html
index 94482b43b..55ce83d77 100644
--- a/docs/build/html/_modules/gillespy2/solvers/utilities/solverutils.html
+++ b/docs/build/html/_modules/gillespy2/solvers/utilities/solverutils.html
@@ -5,7 +5,7 @@
- gillespy2.solvers.utilities.solverutils — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.utilities.solverutils — GillesPy2 1.6.10 documentation
diff --git a/docs/build/html/_modules/gillespy2/stochss/StochSSexport.html b/docs/build/html/_modules/gillespy2/stochss/StochSSexport.html
index 328ed1d1e..86fdb4575 100644
--- a/docs/build/html/_modules/gillespy2/stochss/StochSSexport.html
+++ b/docs/build/html/_modules/gillespy2/stochss/StochSSexport.html
@@ -5,7 +5,7 @@
- gillespy2.stochss.StochSSexport — GillesPy2 1.6.9 documentation
+ gillespy2.stochss.StochSSexport — GillesPy2 1.6.10 documentation
@@ -210,9 +210,9 @@ Source code for gillespy2.stochss.StochSSexport
<
def __add_rules(model, r_type, rules):
for name, rule in rules.items():
try:
- variable = __get_species(species=model['species'], name=rule.variable)
+ variable = __get_species(species=model['species'], name=rule.variable.name)
except IndexError:
- variable = __get_parameter(parameters=model['parameters'], name=rule.variable)
+ variable = __get_parameter(parameters=model['parameters'], name=rule.variable.name)
s_rule = {"compID":model['defaultID'],
"name":name,
@@ -302,6 +302,8 @@ Source code for gillespy2.stochss.StochSSexport
<
:type path: str
"""
+ model.compile_prep()
+
if path is None:
path = f"{model.name}.mdl"
diff --git a/docs/build/html/_modules/index.html b/docs/build/html/_modules/index.html
index 35a386e37..7fd0680f3 100644
--- a/docs/build/html/_modules/index.html
+++ b/docs/build/html/_modules/index.html
@@ -5,7 +5,7 @@
- Overview: module code — GillesPy2 1.6.9 documentation
+ Overview: module code — GillesPy2 1.7.0 documentation
@@ -124,12 +124,10 @@ All modules for which code is available
gillespy2.solvers.cpp.build.template_gen
gillespy2.solvers.cpp.c_decoder
gillespy2.solvers.cpp.c_solver
-gillespy2.solvers.cpp.example_models
gillespy2.solvers.cpp.ode_c_solver
gillespy2.solvers.cpp.ssa_c_solver
gillespy2.solvers.cpp.tau_hybrid_c_solver
gillespy2.solvers.cpp.tau_leaping_c_solver
-gillespy2.solvers.cpp.variable_ssa_c_solver
gillespy2.solvers.numpy.CLE_solver
gillespy2.solvers.numpy.ode_solver
gillespy2.solvers.numpy.ssa_solver
diff --git a/docs/build/html/_sources/classes/gillespy2.solvers.cpp.rst.txt b/docs/build/html/_sources/classes/gillespy2.solvers.cpp.rst.txt
index ea18faa88..1c441baff 100644
--- a/docs/build/html/_sources/classes/gillespy2.solvers.cpp.rst.txt
+++ b/docs/build/html/_sources/classes/gillespy2.solvers.cpp.rst.txt
@@ -28,14 +28,6 @@ gillespy2.solvers.cpp.c\_solver module
:undoc-members:
:show-inheritance:
-gillespy2.solvers.cpp.example\_models module
---------------------------------------------
-
-.. automodule:: gillespy2.solvers.cpp.example_models
- :members:
- :undoc-members:
- :show-inheritance:
-
gillespy2.solvers.cpp.ode\_c\_solver module
-------------------------------------------
@@ -68,14 +60,6 @@ gillespy2.solvers.cpp.tau\_leaping\_c\_solver module
:undoc-members:
:show-inheritance:
-gillespy2.solvers.cpp.variable\_ssa\_c\_solver module
------------------------------------------------------
-
-.. automodule:: gillespy2.solvers.cpp.variable_ssa_c_solver
- :members:
- :undoc-members:
- :show-inheritance:
-
Module contents
---------------
diff --git a/docs/build/html/_sources/classes/gillespy2.solvers.rst.txt b/docs/build/html/_sources/classes/gillespy2.solvers.rst.txt
index 994bd787b..6836f632a 100644
--- a/docs/build/html/_sources/classes/gillespy2.solvers.rst.txt
+++ b/docs/build/html/_sources/classes/gillespy2.solvers.rst.txt
@@ -8,7 +8,6 @@ Subpackages
:maxdepth: 4
gillespy2.solvers.cpp
- gillespy2.solvers.cython
gillespy2.solvers.numpy
gillespy2.solvers.stochkit
gillespy2.solvers.utilities
diff --git a/docs/build/html/_sources/getting_started/basic_usage/basic_usage.rst.txt b/docs/build/html/_sources/getting_started/basic_usage/basic_usage.rst.txt
index 1a39aabb4..5a17d4fb4 100644
--- a/docs/build/html/_sources/getting_started/basic_usage/basic_usage.rst.txt
+++ b/docs/build/html/_sources/getting_started/basic_usage/basic_usage.rst.txt
@@ -24,40 +24,40 @@ Simple example of using GillesPy2
-In GillesPy2, a model is expressed as an object having the parent class ``Model``. Components of the model, such as the reactions, molecular species, and characteristics such as the time span for simulation, are all defined within the subclass definition. The following Python code represents our dimerization model using GillesPy2's facility:
+In GillesPy2, a model is expressed as an object. Components, such as the reactions, molecular species, and characteristics such as the time span for simulation, are all defined within the model. The following Python code represents our dimerization model using GillesPy2's facility:
.. code-block:: python
- import numpy
import gillespy2
- class Dimerization(gillespy2.Model):
- def __init__(self, parameter_values=None):
- # First call the gillespy2.Model initializer.
- super().__init__(self)
-
- # Define parameters for the rates of creation and dissociation.
- k_c = gillespy2.Parameter(name='k_c', expression=0.005)
- k_d = gillespy2.Parameter(name='k_d', expression=0.08)
- self.add_parameter([k_c, k_d])
-
- # Define variables for the molecular species representing M & D.
- m = gillespy2.Species(name='monomer', initial_value=30)
- d = gillespy2.Species(name='dimer', initial_value=0)
- self.add_species([m, d])
-
- # The list of reactants and products for a Reaction object are
- # each a Python dictionary in which the dictionary keys are
- # Species objects and the values are stoichiometries of the
- # species in the reaction.
- r_c = gillespy2.Reaction(name="r_creation", rate=k_c,
- reactants={m:2}, products={d:1})
- r_d = gillespy2.Reaction(name="r_dissociation", rate=k_d,
- reactants={d:1}, products={m:2})
- self.add_reaction([r_c, r_d])
-
- # Set the timespan for the simulation.
- self.timespan(numpy.linspace(0, 100, 101))
+ def Dimerization(parameter_values=None):
+ # First call the gillespy2.Model initializer.
+ model = gillespy2.Model()
+
+ # Define parameters for the rates of creation and dissociation.
+ k_c = gillespy2.Parameter(name='k_c', expression=0.005)
+ k_d = gillespy2.Parameter(name='k_d', expression=0.08)
+ model.add_parameter([k_c, k_d])
+
+ # Define variables for the molecular species representing M & D.
+ m = gillespy2.Species(name='monomer', initial_value=30)
+ d = gillespy2.Species(name='dimer', initial_value=0)
+ model.add_species([m, d])
+
+ # The list of reactants and products for a Reaction object are
+ # each a Python dictionary in which the dictionary keys are
+ # Species objects and the values are stoichiometries of the
+ # species in the reaction.
+ r_c = gillespy2.Reaction(name="r_creation", rate=k_c,
+ reactants={m:2}, products={d:1})
+ r_d = gillespy2.Reaction(name="r_dissociation", rate=k_d,
+ reactants={d:1}, products={m:2})
+ model.add_reaction([r_c, r_d])
+
+ # Set the timespan for the simulation.
+ tspan = gillespy2.TimeSpan.linspace(0, 100, 101)
+ model.timespan(tspan)
+ return model
Given the class definition above, the model can be simulated by first instantiating the class object, and then invoking the ``run()`` method on the object. The following code will run the model 10 times to produce 10 sample trajectories:
@@ -93,28 +93,25 @@ First, let's define a simple model to use in this example.
.. code-block:: Python
- import numpy
import gillespy2
- from gillespy2.solvers.numpy.basic_tau_hybrid_solver import BasicTauHybridSolver
-
+
# Define the model.
- class AutomaticSwitchExample(gillespy2.Model):
- def __init__(self, parameter_values=None):
+ def AutomaticSwitchExample(parameter_values=None):
# First call the gillespy2.Model initializer.
- gillespy2.Model.__init__(self, name="Automatic Switch Example")
+ model = gillespy2.Model(name="Automatic Switch Example")
# Define parameters.
k1 = gillespy2.Parameter(name='k1', expression=3e-4)
k2 = gillespy2.Parameter(name='k2', expression=0.5e-2)
k3 = gillespy2.Parameter(name='k3', expression=2e-1)
- self.add_parameter([k1,k2,k3])
+ model.add_parameter([k1,k2,k3])
# Define species.
A = gillespy2.Species(name='A', initial_value=400)
B = gillespy2.Species(name='B', initial_value=10000)
C = gillespy2.Species(name='C', initial_value=10000)
- self.add_species([A, B, C])
+ model.add_species([A, B, C])
# Define reactions.
r1 = gillespy2.Reaction(name="r1", rate=k1,
@@ -126,10 +123,12 @@ First, let's define a simple model to use in this example.
r3 = gillespy2.Reaction(name="r3", rate=k3,
reactants={C:1}, products={A:1})
- self.add_reaction([r1,r2,r3])
+ model.add_reaction([r1,r2,r3])
# Set the timespan for the simulation.
- self.timespan(numpy.linspace(0, 600, 601))
+ tspan = gillespy2.TimeSpan.linspace(0, 600, 601)
+ model.timespan(tspan)
+ return model
In GillesPy2, the selection of different simulation methods is achieved by supplying a value for the ``solver`` keyword argument to the ``run()`` method on ``Model``. The hybrid solver is selected by passing the value ``BasicTauHybridSolver`` to the ``solver`` keyword argument:
@@ -139,7 +138,7 @@ In GillesPy2, the selection of different simulation methods is achieved by suppl
# Create an instance of the model object, then run the simulation.
model = AutomaticSwitchExample()
- results = model.run(solver=BasicTauHybridSolver)
+ results = model.run(algorithm="Tau-Hybrid")
The following code plots the results.
diff --git a/docs/build/html/_sources/tutorials/tut_toggle_switch/tut_toggle_switch.rst.txt b/docs/build/html/_sources/tutorials/tut_toggle_switch/tut_toggle_switch.rst.txt
index 758c20ebb..e9550fbfe 100644
--- a/docs/build/html/_sources/tutorials/tut_toggle_switch/tut_toggle_switch.rst.txt
+++ b/docs/build/html/_sources/tutorials/tut_toggle_switch/tut_toggle_switch.rst.txt
@@ -7,71 +7,65 @@ First, in a Python script that uses GillesPy2 to perform model simulation, we be
.. code-block:: python
- import numpy
- import matplotlib.pyplot as plt
import gillespy2
- from gillespy2 import Model, Species, Parameter, Reaction
- from gillespy2.solvers.numpy.basic_ode_solver import BasicODESolver
-
+
Next, we define a model. This is a model based on a publication by Gardner et al. in Nature, 1999, and represents a genetic toggle switch in Escherichia coli. In GillesPy2, a model is expressed as an object having the parent class ``Model``. Components of the model, such as the reactions, molecular species, and characteristics such as the time span for simulation, are all defined within the subclass definition. The following Python code represents our model using GillesPy2's facility:
.. code-block:: python
- class ToggleSwitch(Model):
- def __init__(self, parameter_values = None):
+ def ToggleSwitch(parameter_values=None):
# Initialize the model.
- Model.__init__(self, name = "toggle_switch")
+ gillespy2.Model(name="toggle_switch")
# Define parameters.
- alpha1 = Parameter(name = 'alpha1', expression = 1)
- alpha2 = Parameter(name = 'alpha2', expression = 1)
- beta = Parameter(name = 'beta', expression = 2.0)
- gamma = Parameter(name = 'gamma', expression = 2.0)
- mu = Parameter(name = 'mu', expression = 1.0)
- self.add_parameter([alpha1, alpha2, beta, gamma, mu])
+ alpha1 = gillespy2.Parameter(name='alpha1', expression=1)
+ alpha2 = gillespy2.Parameter(name='alpha2', expression=1)
+ beta = gillespy2.Parameter(name='beta', expression=2.0)
+ gamma = gillespy2.Parameter(name='gamma', expression=2.0)
+ mu = gillespy2.Parameter(name='mu', expression=1.0)
+ model.add_parameter([alpha1, alpha2, beta, gamma, mu])
# Define molecular species.
- U = Species(name = 'U', initial_value = 10)
- V = Species(name = 'V', initial_value = 10)
- self.add_species([U, V])
+ U = gillespy2.Species(name='U', initial_value=10)
+ V = gillespy2.Species(name='V', initial_value=10)
+ model.add_species([U, V])
# Define reactions.
- cu = Reaction(name = "r1", reactants = {}, products = {U:1},
- propensity_function = "alpha1/(1+pow(V,beta))")
- cv = Reaction(name = "r2", reactants = {}, products = {V:1},
- propensity_function = "alpha2/(1+pow(U,gamma))")
- du = Reaction(name = "r3", reactants = {U:1}, products = {},
- rate = mu)
- dv = Reaction(name = "r4", reactants = {V:1}, products = {},
- rate = mu)
- self.add_reaction([cu, cv, du, dv])
- self.timespan(numpy.linspace(0, 100, 101))
+ cu = gillespy2.Reaction(name="r1", reactants={}, products={U:1},
+ propensity_function="alpha1/(1+pow(V,beta))")
+ cv = gillespy2.Reaction(name="r2", reactants={}, products={V:1},
+ propensity_function="alpha2/(1+pow(U,gamma))")
+ du = gillespy2.Reaction(name="r3", reactants={U:1}, products={},
+ rate=mu)
+ dv = gillespy2.Reaction(name="r4", reactants={V:1}, products={},
+ rate=mu)
+ model.add_reaction([cu, cv, du, dv])
+
+ tspan = gillespy2.TimeSpan.linspace(0, 100, 101)
+ model.timespan(tspan)
+ return model
-Given the class definition above, the model can be simulated by first instantiating the class object, and then invoking the ``run()`` method on the object. Invoking ``run()`` without any values for the ``solver`` keyword argument makes GillesPy2 use the basic SSA solver.
+Given the class definition above, the model can be simulated by first instantiating the class object, and then invoking the ``run()`` method on the object. Invoking ``run()`` without any values for the ``solver`` keyword argument makes GillesPy2 use the SSA algorithm.
.. code-block:: python
model = ToggleSwitch()
- s_results = model.run(show_labels = False)
+ s_results = model.run()
We can run the model again, this time using a deterministic ODE solver.
.. code-block:: python
- d_results = model.run(solver = BasicODESolver, show_labels = False)
+ d_results = model.run(algorithm="ODE")
Now, let's plot the results of the two methods. First, a plot of the stochastic simulation results:
.. code-block:: python
- plt.plot(s_results[0][:,0], s_results[0][:,1], '-r', label='U')
- plt.plot(s_results[0][:,0], s_results[0][:,2], '-b', label='V')
- plt.plot([0], [11])
- plt.title('Stochastic Switch')
- plt.legend(loc = 'best')
+ s_results.plot(title="Stochastic Switch")
.. image:: stochastic.png
@@ -83,11 +77,7 @@ And here is a plot of the deterministic simulation results:
.. code-block:: python
- plt.plot(d_results[0][:,0], d_results[0][:,1], '-r', label='U')
- plt.plot(d_results[0][:,0], d_results[0][:,2], '-b', label='V')
- plt.plot([0], [11])
- plt.title('Stochastic Switch')
- plt.legend(loc = 'best')
+ d_results.plot(title="Stochastic Switch")
.. image:: ode.png
diff --git a/docs/build/html/_static/documentation_options.js b/docs/build/html/_static/documentation_options.js
index 2da77afc0..a752120bb 100644
--- a/docs/build/html/_static/documentation_options.js
+++ b/docs/build/html/_static/documentation_options.js
@@ -1,6 +1,6 @@
var DOCUMENTATION_OPTIONS = {
URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
- VERSION: '1.6.9',
+ VERSION: '1.7.0',
LANGUAGE: 'en',
COLLAPSE_INDEX: false,
BUILDER: 'html',
diff --git a/docs/build/html/classes/gillespy2.core.html b/docs/build/html/classes/gillespy2.core.html
index 1f6e9acd1..c413f1ab1 100644
--- a/docs/build/html/classes/gillespy2.core.html
+++ b/docs/build/html/classes/gillespy2.core.html
@@ -6,7 +6,7 @@
- gillespy2.core package — GillesPy2 1.6.9 documentation
+ gillespy2.core package — GillesPy2 1.7.0 documentation
@@ -279,6 +279,12 @@ Submodules
gillespy2.core.gillespyError module¶
+
+
-
exception gillespy2.core.gillespyError.BuildError[source]¶
@@ -303,6 +309,12 @@ Submodulesgillespy2.core.gillespyError.SolverError
+
+
-
exception gillespy2.core.gillespyError.InvalidModelError[source]¶
@@ -327,6 +339,12 @@ Submodulesgillespy2.core.gillespyError.ModelError
+
+
-
exception gillespy2.core.gillespyError.ReactionError[source]¶
@@ -339,6 +357,12 @@ SubmodulesException
+
+
-
exception gillespy2.core.gillespyError.SimulationError[source]¶
@@ -399,6 +423,11 @@ Submodulesclassmethod get_supported_features() Set[Type][source]¶
+
+
-
name = 'GillesPySolver'¶
@@ -406,7 +435,7 @@ Submodules
-
-run(model, t=20, number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False, show_labels=None, **kwargs)[source]¶
+run(model, t=20, number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False, **kwargs)[source]¶
Call out and run the solver. Collect the results.
- Parameters
@@ -418,7 +447,6 @@ SubmodulesReturns
@@ -427,6 +455,11 @@ Submodules
+-
+classmethod validate_integrator_options(options: dict[str, float]) dict[str, float][source]¶
+
+
-
classmethod validate_model(sol_model, model)[source]¶
@@ -948,13 +981,13 @@ Submodules
- Parameters
-components (Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, FunctionDefinitions, and TimeSpan or list) – The component or list of components to be added the the model.
+components (Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, FunctionDefinitions, TimeSpan, or list) – The component or list of components to be added the the model.
- Returns
The components that were added to the model.
- Return type
-Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, FunctionDefinitions, and TimeSpan or list
+Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, FunctionDefinitions, TimeSpan, or list
- Raises
ModelError – Component is invalid.
@@ -964,11 +997,20 @@ Submodules
-
-add_assignment_rule(assignment_rules)[source]¶
-Add AssignmentRule or list of AssignmentRules to the model object.
+add_assignment_rule(assignment_rule)[source]¶
+Add an assignment rule, or list of assignment rules to the model.
- Parameters
-assignment_rules (AssignmentRule or list of AssignmentRules) – The AssignmentRule or list of AssignmentRules to be added to the model object.
+assignment_rules (gillespy2.AssignmentRule or list of gillespy2.AssignmentRules) – The assignment rule or list of assignment rules to be added to the model object.
+- Returns
+The assignment rule or list of assignment rules that were added to the model.
+- Return type
+gillespy2.AssignmentRule | list of gillespy2.AssignmentRule
+- Raises
+ModelError – If an invalid assignment rule is provided or if assignment rule validation fails.
@@ -979,41 +1021,76 @@ Submodules
- Parameters
-event (Event, or list of Events) – The event or list of event objects to be added to the model object.
+event (gillespy2.Event | list of gillespy2.Events) – The event or list of event to be added to the model object.
+- Returns
+The event or list of events that were added to the model.
+- Return type
+gillespy2.Event | list of gillespy2.Event
+- Raises
+ModelError – If an invalid event is provided or if event validation fails.
-
-add_function_definition(function_definitions)[source]¶
-Add FunctionDefinition or list of FunctionDefinitions
+add_function_definition(function_definition)[source]¶
+Add function definition, or list of function definitions to the model
- Parameters
-function_definitions (FunctionDefinition or list of FunctionDefinitions.) – The FunctionDefinition, or list of FunctionDefinitions to be added to the model
-object.
+function_definition (gillespy2.FunctionDefinition | list of gillespy2.FunctionDefinitions.) – The function definition, or list of function definitions to be added to the model object.
+- Returns
+The function defintion or list of function definitions that were added to the model.
+- Return type
+gillespy2.FunctionDefinitions | list of gillespy2.FunctionDefinitions
+- Raises
+ModelError – If an invalid function definition is provided.
-
-add_parameter(params)[source]¶
+add_parameter(parameters)[source]¶
Adds a parameter, or list of parameters to the model.
- Parameters
-params (Parameter, or list of parameters) – The parameter or list of parameters to be added to the model object.
+parameters (gillespy2.Parameter | list of gillespy2.Parameter) – The parameter or list of parameters to be added to the model object.
+- Returns
+A parameter or list of Parameters that were added to the model.
+- Return type
+gillespy2.Parameter | list of gillespy2.Parameter
+- Raises
+ModelError – If an invalid parameter is provided or if Parameter.validate fails.
-
-add_rate_rule(rate_rules)[source]¶
+add_rate_rule(rate_rule)[source]¶
Adds a rate rule, or list of rate rules to the model.
- Parameters
-rate_rules (RateRule, or list of RateRules) – The rate rule or list of rate rule objects to be added to the model object.
+rate_rule (gillespy2.RateRule | list of gillespy2.RateRules) – The rate rule or list of rate rules to be added to the model object.
+- Returns
+The rate rule or list of rate rules that were added to the model.
+- Return type
+gillespy2.RateRule | list of gillespy2.RateRule
+- Raises
+ModelError – If an invalid rate rule is provided or if rate rule validation fails.
@@ -1024,57 +1101,80 @@ Submodules
Parameters
-reactions (Reaction, or list of Reactions) – The reaction or list of reaction objects to be added to the model
-object.
+reactions (gillespy2.Reaction | list of gillespy2.Reaction) – The reaction or list of reactions to be added to the model object
+Returns
+The reaction or list of reactions that were added to the model.
+Return type
+gillespy2.Reaction | list of gillespy2.Reaction
+Raises
+ModelError – If an invalid reaction is provided or if Reaction.validate fails.
-
-add_species(obj)[source]¶
+add_species(species)[source]¶
Adds a species, or list of species to the model.
- Parameters
-obj (Species, or list of species) – The species or list of species to be added to the model object
+species (gillespy2.Species | list of gillespy2.Species) – The species or list of species to be added to the model object
+- Returns
+The species or list of species that were added to the model.
+- Return type
+gillespy2.Species | list of gillespy2.Species
+- Raises
+ModelError – If an invalid species is provided or if Species.validate fails.
+
+
-
delete_all_assignment_rules()[source]¶
-Clears all assignment rules from model
+Removes all assignment rules from the model object.
-
delete_all_function_definitions()[source]¶
-Clears all Function Definitions from a model
+Removes all function definitions from the model object.
-
delete_all_parameters()[source]¶
-Deletes all parameters from model.
+Removes all parameters from model object.
-
delete_all_rate_rules()[source]¶
-Clears all of models Rate Rules
+Removes all rate rules from the model object.
-
delete_all_reactions()[source]¶
-Clears all reactions in model
+Removes all reactions from the model object.
@@ -1086,10 +1186,13 @@ Submodules
-
delete_assignment_rule(name)[source]¶
-Removes an assignment rule from a model
+Removes an assignment rule object by model.
- Parameters
-name (str) – Name of AssignmentRule object to be removed from model.
+name (str) – Name of the assignment rule object to be removed.
+- Raises
+ModelError – If the assignment rule is not part of the model.
@@ -1097,10 +1200,10 @@ Submodules
delete_event(name)[source]¶
-Removes specified Event from model
+Removes an event object by name.
- Parameters
-name (str) – Name of Event to be removed.
+name (str) – Name of the event object to be removed.
Submodules
delete_function_definition(name)[source]¶
-Removes specified Function Definition from model
+Removes a function definition object by name.
- Parameters
-name (str) – Name of Function Definition to be removed
+name (str) – Name of the function definition object to be removed.
Submodules
Parameters
-name (str) – Name of the parameter object to be removed
+name (str) – Name of the parameter object to be removed.
+Raises
+ModelError – If the parameter is not part of the model.
Submodules
delete_rate_rule(name)[source]¶
-Removes specified Rate Rule from model
+Removes rate rule object by name.
- Parameters
-name (str) – Name of Rate Rule to be removed.
+name (str) – Name of the rate rule to be removed.
+- Raises
+ModelError – If the rate rule is not part of the model.
Submodules
Parameters
-name (str) – Name of Reaction to be removed,
+name (str) – Name of the reaction object to be removed.
+Raises
+ModelError – If the reaction is not part of the model.
Submodules
Parameters
-name (str) – Name of the species object to be removed
+name (str) – Name of the species object to be removed.
+Raises
+ModelError – If the species is not part of the model.
Submodules
get_all_assignment_rules()[source]¶
-
+Get all of the assignment rules in the model object.
+
- Returns
-dict of models Assignment Rules
+A dict of all assignemt rules in the model, in the form: {name: reaction object}.
@@ -1173,9 +1289,10 @@ Submodules
get_all_events()[source]¶
-
+Get all of the events in the model object.
+
- Returns
-dict of all Event objects
+A dict of all evetns in the model, in the form: {name : event object}
@@ -1183,9 +1300,13 @@ Submodules
get_all_function_definitions()[source]¶
-
+Get all of the function definitions in the model object.
+
- Returns
-Dict of models function definitions
+A dict of all function definitions in the model, in the form {name : function definition object}.
+- Return type
+-
@@ -1193,10 +1314,13 @@ Submodules
get_all_parameters()[source]¶
-
+Get all of the parameters in the model object.
+
- Returns
-A dict of all parameters in the model, of the form:
-{name : parameter object}
+A dict of all parameters in the model, in the form: {name : parameter object}
+- Return type
+-
@@ -1204,9 +1328,13 @@ Submodules
get_all_rate_rules()[source]¶
-
+Get all of the rate rules in the model object.
+
- Returns
-dict of all Rate Rule objects
+A dict of all rate rules in the model, in the form: {name : rate rule object}.
+- Return type
+-
@@ -1214,9 +1342,13 @@ Submodules
get_all_reactions()[source]¶
-
+Get all of the reactions in the model object.
+
- Returns
-dict of all Reaction objects
+A dict of all reactions in the model, in the form: {name : reaction object}.
+- Return type
+-
@@ -1224,23 +1356,33 @@ Submodules
get_all_species()[source]¶
-
+Get all of the species in the model object.
+
- Returns
-A dict of all species in the model, of the form:
-{name : species object}
+A dict of all species in the model, in the form: {name : species object}.
+- Return type
+-
-
-get_assignment_rule(aname)[source]¶
-
+get_assignment_rule(name)[source]¶
+Returns an assignment rule object by name.
+
- Parameters
-aname – Name of Assignment Rule to get
+name (str) – Name of the assignment rule object to be returned.
- Returns
-Assignment Rule object
+The specified assignment rule object.
+- Return type
+gillespy2.AssignmentRule
+- Raises
+ModelError – If the assignment rule is not part of the model.
@@ -1269,40 +1411,57 @@ Submodules
-
-get_element(ename)[source]¶
-Get element specified by name.
+get_element(name)[source]¶
+Get a model element specified by name.
- Parameters
-ename – name of element to search for
+name (str) – Name of the element to be returned.
- Returns
-value of element, or ‘element not found’
+The specified gillespy2.Model element.
+- Return type
+Species, Parameters, Reactions, Events, RateRules, AssignmentRules, FunctionDefinitions, or TimeSpan
+- Raises
+ModelError – If the element is not part of the model.
-
-get_event(ename)[source]¶
-
+get_event(name)[source]¶
+Returns an event object by name.
+
- Parameters
-ename – Name of Event to get
+name (str) – Name of the event object to be returned.
- Returns
-Event object
+The specified event object.
+- Return type
+gillespy2.Event
+- Raises
+ModelError – If the event is not part of the model.
-
-get_function_definition(fname)[source]¶
-
+get_function_definition(name)[source]¶
+Returns a function definition object by name.
+
- Parameters
-fname – name of Function to get
+name (str) – Name of the function definition object to be returned.
- Returns
-FunctionDefinition object
+The specified function definition object.
+- Return type
+gillespy2.FunctionDefinition
@@ -1321,48 +1480,80 @@ Submodules
-
-get_parameter(p_name)[source]¶
+get_parameter(name)[source]¶
Returns a parameter object by name.
- Parameters
-p_name (str) – Name of the parameter object to be returned
+name (str) – Name of the parameter object to be returned
+- Returns
+The specified parameter object.
+- Return type
+gillespy2.Parameter
+- Raises
+ModelError – If the parameter is not part of the model.
-
-get_rate_rule(rname)[source]¶
-
+get_rate_rule(name)[source]¶
+Returns a rate rule object by name.
+
- Parameters
-rname – Name of Rate Rule to get
+name (str) – Name of the rate rule object to be returned.
- Returns
-RateRule object
+The specified rate rule object.
+- Return type
+gillespy2.RateRule
+- Raises
+ModelError – If the rate rule is not part of the model.
-
-get_reaction(rname)[source]¶
-
+get_reaction(name)[source]¶
+Returns a reaction object by name.
+
- Parameters
-rname – name of reaction to return
+name (str) – Name of the reaction object to be returned
- Returns
-Reaction object
+The specified reaction object.
+- Return type
+gillespy2.Reaction
+- Raises
+ModelError – If the reaction is not part of the model.
-
-get_species(s_name)[source]¶
+get_species(name)[source]¶
Returns a species object by name.
- Parameters
-s_name (str) – Name of the species object to be returned:
+name (str) – Name of the species object to be returned.
+- Returns
+The specified species object.
+- Return type
+gillespy2.Species
+- Raises
+ModelError – If the species is not part of the model.
@@ -1381,25 +1572,18 @@ Submodules
-
-problem_with_name(name)[source]¶
-
+problem_with_name(*args)[source]¶
+(deprecated)
+
-
reserved_names = ['vol']¶
-
--
-resolve_parameters()[source]¶
-Internal function:
-attempt to resolve all parameter expressions to scalar floats.
-This methods must be called before exporting the model.
-
-
-
-run(solver=None, timeout=0, t=None, increment=None, show_labels=True, algorithm=None, **solver_args)[source]¶
+run(solver=None, timeout=0, t=None, increment=None, algorithm=None, **solver_args)[source]¶
Function calling simulation of the model. There are a number of
parameters to be set here.
@@ -1458,7 +1641,7 @@ Submodules
-
set_parameter(p_name, expression)[source]¶
-Set the value of an existing parameter “pname” to “expression”.
+Set the value of an existing parameter “pname” to “expression” (deprecated).
- Parameters
@@ -1508,7 +1691,18 @@ Submodules
-
validate_reactants_and_products(reactions)[source]¶
-
+Internal function (deprecated):
+Ensure that the rate and all reactants and products are present in the model
+for the given reaction. This methods must be called before exporting the model.
+
+- Parameters
+reaction (gillespy2.Reaction) – The target reaction to resolve.
+- Raises
+ModelError – If the reaction can’t be resolved.
+
+
@@ -1596,7 +1790,7 @@ Submodules
-gillespy2.core.model.import_SBML(filename, name=None, gillespy_model=None)[source]¶
+gillespy2.core.model.import_SBML(filename, name=None, gillespy_model=None, report_silently_with_sbml_error=False)[source]¶
SBML to GillesPy model converter. NOTE: non-mass-action rates
in terms of concentrations may not be converted for population
simulation. Use caution when importing SBML.
@@ -1606,6 +1800,8 @@ Submodulessanitized_expression(species_mappings, parameter_mappings)[source]¶
-
--
-set_expression(expression)[source]¶
-Sets the expression for a parameter.
-
-- Raises
-ParameterError – expression is of invalid type. expression is set to None.
-
-
-
-
validate(expression=None, coverage='all')[source]¶
@@ -1699,7 +1884,7 @@ Submodulesgillespy2.core.reaction module¶
-
-class gillespy2.core.reaction.Reaction(name='', reactants={}, products={}, propensity_function=None, massaction=False, rate=None, annotation=None)[source]¶
+class gillespy2.core.reaction.Reaction(name=None, reactants=None, products=None, propensity_function=None, ode_propensity_function=None, rate=None, annotation=None, massaction=None)[source]¶
Bases: gillespy2.core.sortableobject.SortableObject, gillespy2.core.jsonify.Jsonify
Models a single reaction. A reaction has its own dicts of species
(reactants and products) and parameters. The reaction’s propensity
@@ -1715,7 +1900,9 @@
Submodules
-
-Annotate(annotation)[source]¶
-Adds a note to the reaction
+Annotate(*args, **kwargs)[source]¶
+Add an annotation to this reaction (deprecated).
- Parameters
-annotation (str) – An optional note about the reaction.
+annotation (str) – Annotation note to be added to reaction
-
-addProduct(S, stoichiometry)[source]¶
-Adds a product to the reaction (species that is created)
+addProduct(*args, **kwargs)[source]¶
+Add a product to this reaction (deprecated)
- Parameters
-S (gillespy2.Species) – Product to add to this reaction.
stoichiometry (int) – The stoichiometry of the given product.
species (spatialpy.core.species.Species) – Species object to be produced by the reaction
stoichiometry (int) – Stoichiometry of this product.
@@ -1756,13 +1943,41 @@ Submodules
-
-addReactant(S, stoichiometry)[source]¶
-Adds a reactant to the reaction (species that is consumed)
+addReactant(*args, **kwargs)[source]¶
+Add a reactant to this reaction (deprecated)
- Parameters
-S (gillespy2.Species) – Reactant to add to this reaction.
stoichiometry (int) – The stoichiometry of the given reactant.
species (spatialpy.core.species.Species) – reactant Species object
stoichiometry (int) – Stoichiometry of this participant reactant
+
+
+
+
+-
+add_product(species, stoichiometry)[source]¶
+Add a product to this reaction
+
+- Parameters
+
+species (spatialpy.core.species.Species | str) – Species object to be produced by the reaction
stoichiometry (int) – Stoichiometry of this product.
+
+
+
+
+-
+add_reactant(species, stoichiometry)[source]¶
+Add a reactant to this reaction
+
+- Parameters
+
+species (spatialpy.core.species.Species) – reactant Species object
stoichiometry (int) – Stoichiometry of this participant reactant
@@ -1770,7 +1985,7 @@ Submodules
-
-create_mass_action()[source]¶
+create_mass_action(*args, **kwargs)[source]¶
Initializes the mass action propensity function given
self.reactants and a single parameter value.
@@ -1798,7 +2013,7 @@ Submodules
-
setType(rxntype)[source]¶
-Sets reaction type to either “mass-action” or “customized”
+Sets reaction type to either “mass-action” or “customized” (deprecated)
- Parameters
rxntype (str) – Either “mass-action” or “customized”
@@ -1806,6 +2021,44 @@ Submodules
+-
+set_annotation(annotation)[source]¶
+Add an annotation to this reaction.
+
+- Parameters
+annotation (str) – Annotation note to be added to reaction
+
+
+
+
+-
+set_propensities(propensity_function=None, ode_propensity_function=None)[source]¶
+Change the reaction to a customized reaction and set the propensities.
+
+- Parameters
+
+propensity_function (str) – The custom propensity function for the reaction. Must be evaluable in the
+namespace of the reaction using C operations.
ode_propensity_function (str) – The custom ode propensity function for the reaction. Must be evaluable in the
+namespace of the reaction using C operations.
+
+
+
+
+-
+set_rate(rate)[source]¶
+Change the reaction to a mass-action reaction and set the rate.
+
+- Parameters
+rate (int | float | str | Parameter) – The rate of the mass-action reaction, take care to note the units.
+
+
+
-
to_dict()[source]¶
@@ -1819,9 +2072,16 @@ Submodules
+-
+validate(reactants=None, products=None, propensity_function=None, ode_propensity_function=None, marate=None, annotation=None, coverage='build')[source]¶
+Check if the reaction is properly formatted.
+Does nothing on sucesss, raises and error on failure.
+
+
-
-verify()[source]¶
+verify(*args, **kwargs)[source]¶
Check if the reaction is properly formatted.
Does nothing on sucesss, raises and error on failure.
@@ -2144,7 +2404,7 @@ SubmodulesParameters
increment (float | int) – Distance between sample points for the species populations during the simulation.
t (int) – End time for the simulation.
t (float | int) – End time for the simulation.
- Returns
@@ -2166,7 +2426,7 @@ Submodules
- Parameters
-t (int) – End time for the simulation.
t (float | int) – End time for the simulation.
num_points (int) – Number of sample points for the species populations during the simulation.
Submodules
+-
+exception gillespy2.core.AssignmentRuleError[source]¶
+-
+
+
-
exception gillespy2.core.BuildError[source]¶
@@ -2362,6 +2628,12 @@ Submodules
+-
+exception gillespy2.core.FunctionDefinitionError[source]¶
+-
+
+
-
class gillespy2.core.GillesPySolver[source]¶
@@ -2377,6 +2649,11 @@ Submodulesclassmethod get_supported_features() Set[Type][source]¶
+
+
-
name = 'GillesPySolver'¶
@@ -2384,7 +2661,7 @@ Submodules
-
-run(model, t=20, number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False, show_labels=None, **kwargs)[source]¶
+run(model, t=20, number_of_trajectories=1, increment=0.05, seed=None, debug=False, profile=False, **kwargs)[source]¶
Call out and run the solver. Collect the results.
- Parameters
@@ -2396,7 +2673,6 @@ SubmodulesReturns
@@ -2405,6 +2681,11 @@ Submodules
+-
+classmethod validate_integrator_options(options: dict[str, float]) dict[str, float][source]¶
+
+
-
classmethod validate_model(sol_model, model)[source]¶
@@ -2707,13 +2988,13 @@ Submodules
- Parameters
-components (Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, FunctionDefinitions, and TimeSpan or list) – The component or list of components to be added the the model.
+components (Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, FunctionDefinitions, TimeSpan, or list) – The component or list of components to be added the the model.
- Returns
The components that were added to the model.
- Return type
-Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, FunctionDefinitions, and TimeSpan or list
+Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, FunctionDefinitions, TimeSpan, or list
- Raises
ModelError – Component is invalid.
@@ -2723,11 +3004,20 @@ Submodules
-
-add_assignment_rule(assignment_rules)[source]¶
-Add AssignmentRule or list of AssignmentRules to the model object.
+add_assignment_rule(assignment_rule)[source]¶
+Add an assignment rule, or list of assignment rules to the model.
- Parameters
-assignment_rules (AssignmentRule or list of AssignmentRules) – The AssignmentRule or list of AssignmentRules to be added to the model object.
+assignment_rules (gillespy2.AssignmentRule or list of gillespy2.AssignmentRules) – The assignment rule or list of assignment rules to be added to the model object.
+- Returns
+The assignment rule or list of assignment rules that were added to the model.
+- Return type
+gillespy2.AssignmentRule | list of gillespy2.AssignmentRule
+- Raises
+ModelError – If an invalid assignment rule is provided or if assignment rule validation fails.
@@ -2738,41 +3028,76 @@ Submodules
- Parameters
-event (Event, or list of Events) – The event or list of event objects to be added to the model object.
+event (gillespy2.Event | list of gillespy2.Events) – The event or list of event to be added to the model object.
+- Returns
+The event or list of events that were added to the model.
+- Return type
+gillespy2.Event | list of gillespy2.Event
+- Raises
+ModelError – If an invalid event is provided or if event validation fails.
-
-add_function_definition(function_definitions)[source]¶
-Add FunctionDefinition or list of FunctionDefinitions
+add_function_definition(function_definition)[source]¶
+Add function definition, or list of function definitions to the model
- Parameters
-function_definitions (FunctionDefinition or list of FunctionDefinitions.) – The FunctionDefinition, or list of FunctionDefinitions to be added to the model
-object.
+function_definition (gillespy2.FunctionDefinition | list of gillespy2.FunctionDefinitions.) – The function definition, or list of function definitions to be added to the model object.
+- Returns
+The function defintion or list of function definitions that were added to the model.
+- Return type
+gillespy2.FunctionDefinitions | list of gillespy2.FunctionDefinitions
+- Raises
+ModelError – If an invalid function definition is provided.
-
-add_parameter(params)[source]¶
+add_parameter(parameters)[source]¶
Adds a parameter, or list of parameters to the model.
- Parameters
-params (Parameter, or list of parameters) – The parameter or list of parameters to be added to the model object.
+parameters (gillespy2.Parameter | list of gillespy2.Parameter) – The parameter or list of parameters to be added to the model object.
+- Returns
+A parameter or list of Parameters that were added to the model.
+- Return type
+gillespy2.Parameter | list of gillespy2.Parameter
+- Raises
+ModelError – If an invalid parameter is provided or if Parameter.validate fails.
-
-add_rate_rule(rate_rules)[source]¶
+add_rate_rule(rate_rule)[source]¶
Adds a rate rule, or list of rate rules to the model.
- Parameters
-rate_rules (RateRule, or list of RateRules) – The rate rule or list of rate rule objects to be added to the model object.
+rate_rule (gillespy2.RateRule | list of gillespy2.RateRules) – The rate rule or list of rate rules to be added to the model object.
+- Returns
+The rate rule or list of rate rules that were added to the model.
+- Return type
+gillespy2.RateRule | list of gillespy2.RateRule
+- Raises
+ModelError – If an invalid rate rule is provided or if rate rule validation fails.
@@ -2783,57 +3108,80 @@ Submodules
Parameters
-reactions (Reaction, or list of Reactions) – The reaction or list of reaction objects to be added to the model
-object.
+reactions (gillespy2.Reaction | list of gillespy2.Reaction) – The reaction or list of reactions to be added to the model object
+Returns
+The reaction or list of reactions that were added to the model.
+Return type
+gillespy2.Reaction | list of gillespy2.Reaction
+Raises
+ModelError – If an invalid reaction is provided or if Reaction.validate fails.
-
-add_species(obj)[source]¶
+add_species(species)[source]¶
Adds a species, or list of species to the model.
- Parameters
-obj (Species, or list of species) – The species or list of species to be added to the model object
+species (gillespy2.Species | list of gillespy2.Species) – The species or list of species to be added to the model object
+- Returns
+The species or list of species that were added to the model.
+- Return type
+gillespy2.Species | list of gillespy2.Species
+- Raises
+ModelError – If an invalid species is provided or if Species.validate fails.
+
+
-
delete_all_assignment_rules()[source]¶
-Clears all assignment rules from model
+Removes all assignment rules from the model object.
-
delete_all_function_definitions()[source]¶
-Clears all Function Definitions from a model
+Removes all function definitions from the model object.
-
delete_all_parameters()[source]¶
-Deletes all parameters from model.
+Removes all parameters from model object.
-
delete_all_rate_rules()[source]¶
-Clears all of models Rate Rules
+Removes all rate rules from the model object.
-
delete_all_reactions()[source]¶
-Clears all reactions in model
+Removes all reactions from the model object.
@@ -2845,10 +3193,13 @@ Submodules
-
delete_assignment_rule(name)[source]¶
-Removes an assignment rule from a model
+Removes an assignment rule object by model.
- Parameters
-name (str) – Name of AssignmentRule object to be removed from model.
+name (str) – Name of the assignment rule object to be removed.
+- Raises
+ModelError – If the assignment rule is not part of the model.
@@ -2856,10 +3207,10 @@ Submodules
delete_event(name)[source]¶
-Removes specified Event from model
+Removes an event object by name.
- Parameters
-name (str) – Name of Event to be removed.
+name (str) – Name of the event object to be removed.
Submodules
delete_function_definition(name)[source]¶
-Removes specified Function Definition from model
+Removes a function definition object by name.
- Parameters
-name (str) – Name of Function Definition to be removed
+name (str) – Name of the function definition object to be removed.
Submodules
Parameters
-name (str) – Name of the parameter object to be removed
+name (str) – Name of the parameter object to be removed.
+Raises
+ModelError – If the parameter is not part of the model.
Submodules
delete_rate_rule(name)[source]¶
-Removes specified Rate Rule from model
+Removes rate rule object by name.
- Parameters
-name (str) – Name of Rate Rule to be removed.
+name (str) – Name of the rate rule to be removed.
+- Raises
+ModelError – If the rate rule is not part of the model.
Submodules
Parameters
-name (str) – Name of Reaction to be removed,
+name (str) – Name of the reaction object to be removed.
+Raises
+ModelError – If the reaction is not part of the model.
Submodules
Parameters
-name (str) – Name of the species object to be removed
+name (str) – Name of the species object to be removed.
+Raises
+ModelError – If the species is not part of the model.
Submodules
get_all_assignment_rules()[source]¶
-
+Get all of the assignment rules in the model object.
+
- Returns
-dict of models Assignment Rules
+A dict of all assignemt rules in the model, in the form: {name: reaction object}.
@@ -2932,9 +3296,10 @@ Submodules
get_all_events()[source]¶
-
+Get all of the events in the model object.
+
- Returns
-dict of all Event objects
+A dict of all evetns in the model, in the form: {name : event object}
@@ -2942,9 +3307,13 @@ Submodules
get_all_function_definitions()[source]¶
-
+Get all of the function definitions in the model object.
+
- Returns
-Dict of models function definitions
+A dict of all function definitions in the model, in the form {name : function definition object}.
+- Return type
+-
@@ -2952,10 +3321,13 @@ Submodules
get_all_parameters()[source]¶
-
+Get all of the parameters in the model object.
+
- Returns
-A dict of all parameters in the model, of the form:
-{name : parameter object}
+A dict of all parameters in the model, in the form: {name : parameter object}
+- Return type
+-
@@ -2963,9 +3335,13 @@ Submodules
get_all_rate_rules()[source]¶
-
+Get all of the rate rules in the model object.
+
- Returns
-dict of all Rate Rule objects
+A dict of all rate rules in the model, in the form: {name : rate rule object}.
+- Return type
+-
@@ -2973,9 +3349,13 @@ Submodules
get_all_reactions()[source]¶
-
+Get all of the reactions in the model object.
+
- Returns
-dict of all Reaction objects
+A dict of all reactions in the model, in the form: {name : reaction object}.
+- Return type
+-
@@ -2983,23 +3363,33 @@ Submodules
get_all_species()[source]¶
-
+Get all of the species in the model object.
+
- Returns
-A dict of all species in the model, of the form:
-{name : species object}
+A dict of all species in the model, in the form: {name : species object}.
+- Return type
+-
-
-get_assignment_rule(aname)[source]¶
-
+get_assignment_rule(name)[source]¶
+Returns an assignment rule object by name.
+
- Parameters
-aname – Name of Assignment Rule to get
+name (str) – Name of the assignment rule object to be returned.
- Returns
-Assignment Rule object
+The specified assignment rule object.
+- Return type
+gillespy2.AssignmentRule
+- Raises
+ModelError – If the assignment rule is not part of the model.
@@ -3028,40 +3418,57 @@ Submodules
-
-get_element(ename)[source]¶
-Get element specified by name.
+get_element(name)[source]¶
+Get a model element specified by name.
- Parameters
-ename – name of element to search for
+name (str) – Name of the element to be returned.
- Returns
-value of element, or ‘element not found’
+The specified gillespy2.Model element.
+- Return type
+Species, Parameters, Reactions, Events, RateRules, AssignmentRules, FunctionDefinitions, or TimeSpan
+- Raises
+ModelError – If the element is not part of the model.
-
-get_event(ename)[source]¶
-
+get_event(name)[source]¶
+Returns an event object by name.
+
- Parameters
-ename – Name of Event to get
+name (str) – Name of the event object to be returned.
- Returns
-Event object
+The specified event object.
+- Return type
+gillespy2.Event
+- Raises
+ModelError – If the event is not part of the model.
-
-get_function_definition(fname)[source]¶
-
+get_function_definition(name)[source]¶
+Returns a function definition object by name.
+
- Parameters
-fname – name of Function to get
+name (str) – Name of the function definition object to be returned.
- Returns
-FunctionDefinition object
+The specified function definition object.
+- Return type
+gillespy2.FunctionDefinition
@@ -3080,48 +3487,80 @@ Submodules
-
-get_parameter(p_name)[source]¶
+get_parameter(name)[source]¶
Returns a parameter object by name.
- Parameters
-p_name (str) – Name of the parameter object to be returned
+name (str) – Name of the parameter object to be returned
+- Returns
+The specified parameter object.
+- Return type
+gillespy2.Parameter
+- Raises
+ModelError – If the parameter is not part of the model.
-
-get_rate_rule(rname)[source]¶
-
+get_rate_rule(name)[source]¶
+Returns a rate rule object by name.
+
- Parameters
-rname – Name of Rate Rule to get
+name (str) – Name of the rate rule object to be returned.
- Returns
-RateRule object
+The specified rate rule object.
+- Return type
+gillespy2.RateRule
+- Raises
+ModelError – If the rate rule is not part of the model.
-
-get_reaction(rname)[source]¶
-
+get_reaction(name)[source]¶
+Returns a reaction object by name.
+
- Parameters
-rname – name of reaction to return
+name (str) – Name of the reaction object to be returned
- Returns
-Reaction object
+The specified reaction object.
+- Return type
+gillespy2.Reaction
+- Raises
+ModelError – If the reaction is not part of the model.
-
-get_species(s_name)[source]¶
+get_species(name)[source]¶
Returns a species object by name.
- Parameters
-s_name (str) – Name of the species object to be returned:
+name (str) – Name of the species object to be returned.
+- Returns
+The specified species object.
+- Return type
+gillespy2.Species
+- Raises
+ModelError – If the species is not part of the model.
@@ -3140,25 +3579,18 @@ Submodules
-
-problem_with_name(name)[source]¶
-
+problem_with_name(*args)[source]¶
+(deprecated)
+
-
reserved_names = ['vol']¶
-
--
-resolve_parameters()[source]¶
-Internal function:
-attempt to resolve all parameter expressions to scalar floats.
-This methods must be called before exporting the model.
-
-
-
-run(solver=None, timeout=0, t=None, increment=None, show_labels=True, algorithm=None, **solver_args)[source]¶
+run(solver=None, timeout=0, t=None, increment=None, algorithm=None, **solver_args)[source]¶
Function calling simulation of the model. There are a number of
parameters to be set here.
@@ -3217,7 +3648,7 @@ Submodules
-
set_parameter(p_name, expression)[source]¶
-Set the value of an existing parameter “pname” to “expression”.
+Set the value of an existing parameter “pname” to “expression” (deprecated).
- Parameters
@@ -3267,7 +3698,18 @@ Submodules
-
validate_reactants_and_products(reactions)[source]¶
-
+Internal function (deprecated):
+Ensure that the rate and all reactants and products are present in the model
+for the given reaction. This methods must be called before exporting the model.
+
+- Parameters
+reaction (gillespy2.Reaction) – The target reaction to resolve.
+- Raises
+ModelError – If the reaction can’t be resolved.
+
+
@@ -3375,17 +3817,6 @@ Submodulessanitized_expression(species_mappings, parameter_mappings)[source]¶
-
--
-set_expression(expression)[source]¶
-Sets the expression for a parameter.
-
-- Raises
-ParameterError – expression is of invalid type. expression is set to None.
-
-
-
-
validate(expression=None, coverage='all')[source]¶
@@ -3434,9 +3865,15 @@ Submodules
+-
+exception gillespy2.core.RateRuleError[source]¶
+-
+
+
-
-class gillespy2.core.Reaction(name='', reactants={}, products={}, propensity_function=None, massaction=False, rate=None, annotation=None)[source]¶
+class gillespy2.core.Reaction(name=None, reactants=None, products=None, propensity_function=None, ode_propensity_function=None, rate=None, annotation=None, massaction=None)[source]¶
Bases: gillespy2.core.sortableobject.SortableObject, gillespy2.core.jsonify.Jsonify
Models a single reaction. A reaction has its own dicts of species
(reactants and products) and parameters. The reaction’s propensity
@@ -3452,7 +3889,9 @@
Submodules
-
-Annotate(annotation)[source]¶
-Adds a note to the reaction
+Annotate(*args, **kwargs)[source]¶
+Add an annotation to this reaction (deprecated).
- Parameters
-annotation (str) – An optional note about the reaction.
+annotation (str) – Annotation note to be added to reaction
-
-addProduct(S, stoichiometry)[source]¶
-Adds a product to the reaction (species that is created)
+addProduct(*args, **kwargs)[source]¶
+Add a product to this reaction (deprecated)
- Parameters
-S (gillespy2.Species) – Product to add to this reaction.
stoichiometry (int) – The stoichiometry of the given product.
species (spatialpy.core.species.Species) – Species object to be produced by the reaction
stoichiometry (int) – Stoichiometry of this product.
@@ -3493,13 +3932,41 @@ Submodules
-
-addReactant(S, stoichiometry)[source]¶
-Adds a reactant to the reaction (species that is consumed)
+addReactant(*args, **kwargs)[source]¶
+Add a reactant to this reaction (deprecated)
- Parameters
-S (gillespy2.Species) – Reactant to add to this reaction.
stoichiometry (int) – The stoichiometry of the given reactant.
species (spatialpy.core.species.Species) – reactant Species object
stoichiometry (int) – Stoichiometry of this participant reactant
+
+
+
+
+-
+add_product(species, stoichiometry)[source]¶
+Add a product to this reaction
+
+- Parameters
+
+species (spatialpy.core.species.Species | str) – Species object to be produced by the reaction
stoichiometry (int) – Stoichiometry of this product.
+
+
+
+
+-
+add_reactant(species, stoichiometry)[source]¶
+Add a reactant to this reaction
+
+- Parameters
+
+species (spatialpy.core.species.Species) – reactant Species object
stoichiometry (int) – Stoichiometry of this participant reactant
@@ -3507,7 +3974,7 @@ Submodules
-
-create_mass_action()[source]¶
+create_mass_action(*args, **kwargs)[source]¶
Initializes the mass action propensity function given
self.reactants and a single parameter value.
@@ -3535,7 +4002,7 @@ Submodules
setType(rxntype)[source]¶
-Sets reaction type to either “mass-action” or “customized”
+Sets reaction type to either “mass-action” or “customized” (deprecated)
- Parameters
rxntype (str) – Either “mass-action” or “customized”
@@ -3543,6 +4010,44 @@ Submodules
+-
+set_annotation(annotation)[source]¶
+Add an annotation to this reaction.
+
+- Parameters
+annotation (str) – Annotation note to be added to reaction
+
+
+
+
+-
+set_propensities(propensity_function=None, ode_propensity_function=None)[source]¶
+Change the reaction to a customized reaction and set the propensities.
+
+- Parameters
+
+propensity_function (str) – The custom propensity function for the reaction. Must be evaluable in the
+namespace of the reaction using C operations.
ode_propensity_function (str) – The custom ode propensity function for the reaction. Must be evaluable in the
+namespace of the reaction using C operations.
+
+
+
+
+-
+set_rate(rate)[source]¶
+Change the reaction to a mass-action reaction and set the rate.
+
+- Parameters
+rate (int | float | str | Parameter) – The rate of the mass-action reaction, take care to note the units.
+
+
+
-
to_dict()[source]¶
@@ -3556,9 +4061,16 @@ Submodules
+-
+validate(reactants=None, products=None, propensity_function=None, ode_propensity_function=None, marate=None, annotation=None, coverage='build')[source]¶
+Check if the reaction is properly formatted.
+Does nothing on sucesss, raises and error on failure.
+
+
-
-verify()[source]¶
+verify(*args, **kwargs)[source]¶
Check if the reaction is properly formatted.
Does nothing on sucesss, raises and error on failure.
@@ -3761,6 +4273,12 @@ SubmodulesException
-
exception gillespy2.core.SimulationError[source]¶
@@ -3942,7 +4460,7 @@ SubmodulesParameters
increment (float | int) – Distance between sample points for the species populations during the simulation.
t (int) – End time for the simulation.
t (float | int) – End time for the simulation.
- Returns
@@ -3964,7 +4482,7 @@ Submodules
- Parameters
-t (int) – End time for the simulation.
t (float | int) – End time for the simulation.
num_points (int) – Number of sample points for the species populations during the simulation.
Submodules
-
-gillespy2.core.import_SBML(filename, name=None, gillespy_model=None)[source]¶
+gillespy2.core.import_SBML(filename, name=None, gillespy_model=None, report_silently_with_sbml_error=False)[source]¶
SBML to GillesPy model converter. NOTE: non-mass-action rates
in terms of concentrations may not be converted for population
simulation. Use caution when importing SBML.
@@ -4403,6 +4921,8 @@ Submodules
- gillespy2 package — GillesPy2 1.6.9 documentation
+ gillespy2 package — GillesPy2 1.7.0 documentation
@@ -153,21 +153,13 @@ SubpackagesSubmodules
- gillespy2.solvers.cpp.c_decoder module
- gillespy2.solvers.cpp.c_solver module
-- gillespy2.solvers.cpp.example_models module
- gillespy2.solvers.cpp.ode_c_solver module
- gillespy2.solvers.cpp.ssa_c_solver module
- gillespy2.solvers.cpp.tau_hybrid_c_solver module
- gillespy2.solvers.cpp.tau_leaping_c_solver module
-- gillespy2.solvers.cpp.variable_ssa_c_solver module
- Module contents
-- gillespy2.solvers.cython package
-
- gillespy2.solvers.numpy package
- Submodules
- gillespy2.solvers.numpy.CLE_solver module
diff --git a/docs/build/html/classes/gillespy2.sbml.html b/docs/build/html/classes/gillespy2.sbml.html
index 713eecedc..40b899b2c 100644
--- a/docs/build/html/classes/gillespy2.sbml.html
+++ b/docs/build/html/classes/gillespy2.sbml.html
@@ -6,7 +6,7 @@
- gillespy2.sbml package — GillesPy2 1.6.9 documentation
+ gillespy2.sbml package — GillesPy2 1.7.0 documentation
@@ -140,7 +140,7 @@ Submodulesgillespy2.sbml.SBMLimport module¶
-
-gillespy2.sbml.SBMLimport.convert(filename, model_name=None, gillespy_model=None)[source]¶
+gillespy2.sbml.SBMLimport.convert(filename, model_name=None, gillespy_model=None, report_silently_with_sbml_error=False)[source]¶
diff --git a/docs/build/html/classes/gillespy2.solvers.auto.html b/docs/build/html/classes/gillespy2.solvers.auto.html
index 23e0fc9ca..f75fde6c1 100644
--- a/docs/build/html/classes/gillespy2.solvers.auto.html
+++ b/docs/build/html/classes/gillespy2.solvers.auto.html
@@ -6,7 +6,7 @@
- gillespy2.solvers.auto package — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.auto package — GillesPy2 1.7.0 documentation
diff --git a/docs/build/html/classes/gillespy2.solvers.cpp.build.html b/docs/build/html/classes/gillespy2.solvers.cpp.build.html
index f204e9a49..0eb3c827e 100644
--- a/docs/build/html/classes/gillespy2.solvers.cpp.build.html
+++ b/docs/build/html/classes/gillespy2.solvers.cpp.build.html
@@ -6,7 +6,7 @@
- gillespy2.solvers.cpp.build package — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp.build package — GillesPy2 1.7.0 documentation
@@ -16,7 +16,7 @@
-
+
@@ -85,7 +85,7 @@ Related Topics
- gillespy2.solvers package
@@ -879,7 +879,7 @@ Submodulesgillespy2.solvers.cpp package
-
- gillespy2.solvers.cython package
+ gillespy2.solvers.numpy package
→
diff --git a/docs/build/html/classes/gillespy2.solvers.cpp.html b/docs/build/html/classes/gillespy2.solvers.cpp.html
index 47f3f363d..fbe8061ad 100644
--- a/docs/build/html/classes/gillespy2.solvers.cpp.html
+++ b/docs/build/html/classes/gillespy2.solvers.cpp.html
@@ -6,7 +6,7 @@
- gillespy2.solvers.cpp package — GillesPy2 1.6.9 documentation
+ gillespy2.solvers.cpp package — GillesPy2 1.7.0 documentation
@@ -345,16 +345,6 @@ Submodules
-gillespy2.solvers.cpp.example_models module¶
-
--
-class gillespy2.solvers.cpp.example_models.Example(parameter_values=None)[source]¶
-Bases: gillespy2.core.model.Model
-This is a simple example for mass-action degradation of species S.
-
-
gillespy2.solvers.cpp.ode_c_solver module¶
@@ -362,6 +352,8 @@ Submodules
class gillespy2.solvers.cpp.ode_c_solver.ODECSolver(model: Optional[gillespy2.core.model.Model] = None, output_directory: Optional[str] = None, delete_directory: bool = True, resume=None, variable: bool = False)[source]¶
Bases: gillespy2.core.gillespySolver.GillesPySolver, gillespy2.solvers.cpp.c_solver.CSolver
+This Solver produces the deterministic continuous solution via Ordinary Differential Equations.
+Uses integrators from SUNDIALS to perform calculations used to produce solutions.
-
build_engine: BuildEngine¶
@@ -370,13 +362,16 @@ Submodules
-
get_solver_settings()[source]¶
-
-- Returns
-Tuple of strings, denoting all keyword argument for this solvers run() method.
-
+Returns a list of arguments supported by odc_c_solver.run.
+:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+:rtype: tuple
+
+
-
name = 'ODECSolver'¶
@@ -384,23 +379,30 @@ Submodules
-
-run(model: Optional[gillespy2.core.model.Model] = None, t: Optional[int] = None, number_of_trajectories: int = 1, timeout: int = 0, increment: Optional[int] = None, seed: Optional[int] = None, debug: bool = False, profile: bool = False, variables={}, resume=None, live_output: Optional[str] = None, live_output_options: dict = {}, **kwargs)[source]¶
-Call out and run the solver. Collect the results.
-
+run(model: Optional[gillespy2.core.model.Model] = None, t: Optional[int] = None, number_of_trajectories: int = 1, timeout: int = 0, increment: Optional[int] = None, seed: Optional[int] = None, debug: bool = False, profile: bool = False, variables={}, resume=None, live_output: Optional[str] = None, live_output_options: dict = {}, integrator_options: Optional[dict[str, float]] = None, **kwargs)[source]¶
+
- Parameters
-model (gillespy.Model) – The model on which the solver will operate.
t (int) – The end time of the solver
number_of_trajectories (int) – The number of times to sample the chemical master equation. Each
-trajectory will be returned at the end of the simulation.
increment (float) – The time step of the solution
seed (int) – The random seed for the simulation. Defaults to None.
debug (bool) – Set to True to provide additional debug information about the simulation.
show_labels (bool) – Use names of species as index of result object rather than position numbers.
model (gillespy2.Model) – The model on which the solver will operate. (Deprecated)
t (int) – End time of simulation.
number_of_trajectories (int) – Number of trajectories to simulate.
+This is deterministic and will always have same results.
timeout (int) – If set, if simulation takes longer than timeout, will exit.
increment (float) – Time step increment for plotting.
seed (int) – The random seed for the simulation. Optional, defaults to None.
variables (dict) – Dictionary of species and their data that will override existing species data.
resume (gillespy2.Results) – Result of a previously run simulation, to be resumed.
live_output (str) – The type of output to be displayed by solver. Can be “progress”, “text”, or “graph”.
live_output_options (dict) – Dictionary that contains options for live_output. By default {“interval”:1}.
+“interval” specifies seconds between displaying.
+“clear_output” specifies if display should be refreshed with each display.
- Returns
-Simulation trajectories.
+A result object containing the results of the simulation.
+- Return type
+gillespy2.Results
@@ -419,6 +421,7 @@ Submodules
class gillespy2.solvers.cpp.ssa_c_solver.SSACSolver(model: Optional[gillespy2.core.model.Model] = None, output_directory: Optional[str] = None, delete_directory: bool = True, resume=None, variable: bool = False)[source]¶
Bases: gillespy2.core.gillespySolver.GillesPySolver, gillespy2.solvers.cpp.c_solver.CSolver
+This solver produces simulations of systems via Stochastic Simulation Algorithm.
-
build_engine: BuildEngine¶
@@ -427,11 +430,9 @@ Submodules
-
get_solver_settings()[source]¶
-
-- Returns
-Tuple of strings, denoting all keyword argument for this solvers run() method.
-
+Returns a list of arguments supported by ssa_c_solver.run.
+:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+:rtype: tuple
@@ -453,7 +454,6 @@ SubmodulesReturns
@@ -476,14 +476,37 @@ Submodules
class gillespy2.solvers.cpp.tau_hybrid_c_solver.TauHybridCSolver(model: Optional[gillespy2.core.model.Model] = None, output_directory: Optional[str] = None, delete_directory: bool = True, resume=None, variable: bool = False)[source]¶
Bases: gillespy2.core.gillespySolver.GillesPySolver, gillespy2.solvers.cpp.c_solver.CSolver
+This solver uses a root-finding interpretation of the direct SSA method,
+along with ODE solvers to simulate ODE and Stochastic systems
+interchangeably or simultaneously.
-
class ErrorStatus(value)[source]¶
Bases: enum.IntEnum
An enumeration.
+
+-
+INTEGRATOR_FAILED = 3¶
+
+
+
+-
+INVALID_AFTER_SSA = 4¶
+
+
+
+
+-
+NEGATIVE_STATE_NO_SSA_REACTION = 5¶
+
+
+
+-
+UNKNOWN = 1¶
@@ -496,11 +519,9 @@ Submodules
-
get_solver_settings()[source]¶
-
-- Returns
-Tuple of strings, denoting all keyword argument for this solvers run() method.
-
+Returns a list of arguments supported by tau_hybrid_c_solver.run.
+:return: Tuple of strings, denoting all keyword argument for this solvers run() method.
+:rtype: tuple
@@ -508,6 +529,11 @@ Submodulesclassmethod get_supported_features()[source]¶
+
+
-
name = 'TauHybridCSolver'¶
@@ -515,23 +541,34 @@ Submodules
-
-run(model: Optional[gillespy2.core.model.Model] = None, t: Optional[int] = None, number_of_trajectories: int = 1, timeout: int = 0, increment: Optional[int] = None, seed: Optional[int] = None, debug: bool = False, profile: bool = False, variables={}, resume=None, live_output: Optional[str] = None, live_output_options: dict = {}, tau_step: int = 0.03, tau_tol=0.03, **kwargs)[source]¶
-Call out and run the solver. Collect the results.
-
+run(model: Optional[gillespy2.core.model.Model] = None, t: Optional[int] = None, number_of_trajectories: int = 1, timeout: int = 0, increment: Optional[int] = None, seed: Optional[int] = None, debug: bool = False, profile: bool = False, variables={}, resume=None, live_output: Optional[str] = None, live_output_options: dict = {}, tau_step: int = 0.03, tau_tol=0.03, integrator_options: Optional[dict[str, float]] = None, **kwargs)[source]¶
+
- Parameters
-model (gillespy.Model) – The model on which the solver will operate.
t (int) – The end time of the solver
number_of_trajectories (int) – The number of times to sample the chemical master equation. Each
-trajectory will be returned at the end of the simulation.
increment (float) – The time step of the solution
seed (int) – The random seed for the simulation. Defaults to None.
debug (bool) – Set to True to provide additional debug information about the simulation.
show_labels (bool) – Use names of species as index of result object rather than position numbers.
model (gillespy2.Model) – The model on which the solver will operate. (Deprecated)
t (int) – End time of simulation.
number_of_trajectories (int) – Number of trajectories to simulate. By default number_of_trajectories = 1.
timeout (int) – If set, if simulation takes longer than timeout, will exit.
increment (float) – Time step increment for plotting.
seed (int) – The random seed for the simulation. Optional, defaults to None.
variables (dict) – Dictionary of species and their data that will override existing species data.
resume (gillespy2.Results) – Result of a previously run simulation, to be resumed.
live_output (str) – The type of output to be displayed by solver. Can be “progress”, “text”, or “graph”.
live_output_options (dict) – dictionary contains options for live_output. By default {“interval”:1}.
+“interval” specifies seconds between displaying.
+“clear_output” specifies if display should be refreshed with each display.
tau_tol – Tolerance level for Tau leaping algorithm. Larger tolerance values will
- Returns
-Simulation trajectories.
+
+result in larger tau steps. Default value is 0.03.
+:type tau_tol: float
+
+- Returns
+A result object containing the results of the simulation.
+- Return type
+gillespy2.Results
@@ -550,6 +587,10 @@ Submodules
class gillespy2.solvers.cpp.tau_leaping_c_solver.TauLeapingCSolver(model: Optional[gillespy2.core.model.Model] = None, output_directory: Optional[str] = None, delete_directory: bool = True, resume=None, variable: bool = False)[source]¶
Bases: gillespy2.core.gillespySolver.GillesPySolver, gillespy2.solvers.cpp.c_solver.CSolver
+A Tau Leaping solver for GillesPy2 models. This solver uses an algorithm that calculates
+multiple reactions in a single step over a given tau step size. The change in propensities
+over this step are bounded by relative change in state, yielding greatly improved
+run-time performance with very little trade-off in accuracy.
-
build_engine: BuildEngine¶
@@ -558,11 +599,9 @@ Submodules
-
get_solver_settings()[source]¶
-
-- Returns
-Tuple of strings, denoting all keyword argument for this solvers run() method.
-
+Returns a list of arguments supported by tau_leaping_c_solver.run.
+:returns: Tuple of strings, denoting all keyword argument for this solvers run() method.
+:rtype: tuple
@@ -573,22 +612,33 @@ Submodules
-
run(model: Optional[gillespy2.core.model.Model] = None, t: Optional[int] = None, number_of_trajectories: int = 1, timeout: int = 0, increment: Optional[int] = None, seed: Optional[int] = None, debug: bool = False, profile: bool = False, variables={}, resume=None, live_output: Optional[str] = None, live_output_options: dict = {}, tau_tol=0.03, **kwargs)[source]¶
-Call out and run the solver. Collect the results.
-
+
- Parameters
-model (gillespy.Model) – The model on which the solver will operate.
t (int) – The end time of the solver
number_of_trajectories (int) – The number of times to sample the chemical master equation. Each
-trajectory will be returned at the end of the simulation.
increment (float) – The time step of the solution
seed (int) – The random seed for the simulation. Defaults to None.
debug (bool) – Set to True to provide additional debug information about the simulation.
show_labels (bool) – Use names of species as index of result object rather than position numbers.
model (gillespy2.Model) – The model on which the solver will operate. (Deprecated)
t (int) – End time of simulation.
number_of_trajectories (int) – Number of trajectories to simulate. By default number_of_trajectories = 1.
timeout (int) – If set, if simulation takes longer than timeout, will exit.
increment (float) – Time step increment for plotting.
seed (int) – The random seed for the simulation. Optional, defaults to None.
variables (dict) – Dictionary of species and their data that will override existing species data.
resume (gillespy2.Results) – Result of a previously run simulation, to be resumed.
live_output (str) – The type of output to be displayed by solver. Can be “progress”, “text”, or “graph”.
live_output_options (dict) – dictionary contains options for live_output. By default {“interval”:1}.
+“interval” specifies seconds between displaying.
+“clear_output” specifies if display should be refreshed with each display.
tau_tol – Tolerance level for Tau leaping algorithm. Larger tolerance values will
- Returns
-Simulation trajectories.
+
+result in larger tau steps. Default value is 0.03.
+:type tau_tol: float
+
+- Returns
+A result object containing the results of the simulation
+- Return type
+gillespy2.Results
@@ -600,25 +650,6 @@ Submodules
-gillespy2.solvers.cpp.variable_ssa_c_solver module¶
-
--
-class gillespy2.solvers.cpp.variable_ssa_c_solver.VariableSSACSolver[source]¶
-Bases: gillespy2.solvers.cpp.ssa_c_solver.SSACSolver
-
--
-build_engine