def test_add_rate_rule_dict(self):
species2 = gillespy2.Species('test_species2',initial_value=2, mode ='continuous')
species3 = gillespy2.Species('test_species3',initial_value=3, mode='continuous')
rule2 = gillespy2.RateRule(species2, 'cos(t)')
rule3 = gillespy2.RateRule(species3, 'sin(t)')
rate_rule_dict = {'rule2' :rule2, 'rule3':rule3}
self.model.add_species([species2,species3])
with self.assertRaises(ParameterError):
self.model.add_rate_rule(rate_rule_dict)
def test_model_add__multiple_components__in_order(self):
import gillespy2
s1 = gillespy2.Species(name="s1", initial_value=29)
k1 = gillespy2.Parameter(name="k1", expression=29)
r1 = gillespy2.Reaction(name="r1", reactants={"s1": 1}, rate="k1")
rr1 = gillespy2.RateRule(name="rr1", variable="k1", formula="29")
ar1 = gillespy2.AssignmentRule(name="ar1", variable="s1", formula="29")
ea = gillespy2.EventAssignment(name="ea",
variable="k1",
expression="29")
et = gillespy2.EventTrigger(expression="t > 29")
e1 = gillespy2.Event(name="e1", trigger=et, assignments=[ea])
divide = gillespy2.FunctionDefinition(name="divide",
function="x / y",
args=["x", "y"])
tspan = gillespy2.TimeSpan(range(100))
model = gillespy2.Model(name="Test Model")
model.add([s1, k1, r1, rr1, ar1, e1, divide, tspan])
self.assertIn("ar1", model.listOfAssignmentRules)
self.assertIn("e1", model.listOfEvents)
self.assertIn("divide", model.listOfFunctionDefinitions)
self.assertIn("k1", model.listOfParameters)
self.assertIn("rr1", model.listOfRateRules)
self.assertIn("r1", model.listOfReactions)
self.assertIn("s1", model.listOfSpecies)
self.assertEqual(tspan, model.tspan)
def test_add_rate_rule_dict(self):
model = create_decay()
species2 = gillespy2.Species('test_species2',
initial_value=2,
mode='continuous')
species3 = gillespy2.Species('test_species3',
initial_value=3,
mode='continuous')
rule2 = gillespy2.RateRule('rule2', species2, 'cos(t)')
rule3 = gillespy2.RateRule(name='rule3',
variable=species3,
formula='sin(t)')
rate_rule_dict = {'rule2': rule2, 'rule3': rule3}
model.add_species([species2, species3])
with self.assertRaises(ModelError):
model.add_rate_rule(rate_rule_dict)
def test_add_rate_rule(self):
model = Example()
species = gillespy2.Species('test_species', initial_value=1)
rule = gillespy2.RateRule(name='rr1',formula='test_species+1',variable='test_species')
model.add_species([species])
model.add_rate_rule([rule])
results = model.run()
self.assertEqual(results[0].solver_name, 'TauHybridSolver')
def create_rate_rule_test_model(parameter_values=None):
model = gillespy2.Model(name="RateRuleTestModel")
s1 = gillespy2.Species(name="S1", initial_value=0.015, mode='continuous')
s2 = gillespy2.Species(name="S2", initial_value=0.0, mode='continuous')
s3 = gillespy2.Species(name="S3", initial_value=1.0, mode='continuous')
model.add_species([s1, s2, s3])
k1 = gillespy2.Parameter(name="k1", expression="1.0")
model.add_parameter([k1])
rule1 = gillespy2.RateRule(name="rule1", variable="S1", formula="-k1*S1")
rule2 = gillespy2.RateRule(name="rule2", variable="S2", formula="k1*S1")
rule3 = gillespy2.RateRule(name="rule3", variable="S3", formula="0.015-(S1+S2)")
model.add_rate_rule([rule1, rule2, rule3])
model.timespan(numpy.linspace(0, 20, 51))
return model
def test_add_bad_expression_rate_rule_dict(self):
model = create_decay()
species2 = gillespy2.Species('test_species2',
initial_value=2,
mode='continuous')
rule = gillespy2.RateRule(variable=species2, formula='')
with self.assertRaises(ModelError):
model.add_rate_rule(rule)
def test_add_rate_rule(self):
species = gillespy2.Species('test_species',
initial_value=1,
mode='continuous')
rule = gillespy2.RateRule(species, 'cos(t)')
self.model.add_species([species])
self.model.add_rate_rule([rule])
self.model.run(solver=BasicTauHybridSolver)
def setUpClass(cls):
cls.solvers = [
SSACSolver,
ODESolver,
NumPySSASolver,
TauLeapingSolver,
TauHybridSolver,
ODECSolver,
TauLeapingCSolver,
TauHybridCSolver,
]
cls.sbml_features = {
"AssignmentRule": lambda model, variable:
model.add_assignment_rule(gillespy2.AssignmentRule(variable=variable, formula="1/(t+1)")),
"RateRule": lambda model, variable:
model.add_rate_rule(gillespy2.RateRule(variable=variable, formula="2*t")),
"Event": lambda model, variable:
model.add_event(gillespy2.Event(
trigger=gillespy2.EventTrigger(expression="t>1"),
assignments=[gillespy2.EventAssignment(variable=variable, expression="100")]
)),
"FunctionDefinition": lambda model, variable:
model.add_function_definition(
gillespy2.FunctionDefinition(name="fn", function="variable", args=["variable"])),
}
# List of supported SBML features for each solver.
# When a feature is implemented for a particular solver, add the feature to its list.
cls.solver_supported_sbml_features = {
NumPySSASolver: [],
TauLeapingSolver: [],
ODESolver: [],
TauHybridSolver: [
"AssignmentRule",
"RateRule",
"Event",
"FunctionDefinition",
],
SSACSolver: [],
ODECSolver: [],
TauLeapingCSolver: [],
TauHybridCSolver: [
"RateRule",
"Event",
],
}
cls.model = create_decay()
cls.results = {}
cls.labeled_results = {}
cls.labeled_results_more_trajectories = {}
def test_add_rate_rule(self):
model = create_decay()
species = gillespy2.Species('test_species', initial_value=1)
rule = gillespy2.RateRule(name='rr1',
formula='test_species+1',
variable='test_species')
model.add_species([species])
model.add_rate_rule([rule])
results = model.run()
valid_solvers = ('TauHybridSolver', 'TauHybridCSolver')
self.assertIn(results[0].solver_name, valid_solvers)
def __get_rules(sbml_model, gillespy_model, errors):
for i in range(sbml_model.getNumRules()):
rule = sbml_model.getRule(i)
rule_name = rule.getId()
rule_variable = rule.getVariable()
rule_string = __get_math(rule.getMath())
if rule_variable in gillespy_model.listOfParameters:
# Treat Non-Constant Parameters as Species
value = gillespy_model.listOfParameters[rule_variable].expression
species = gillespy2.Species(name=rule_variable,
initial_value=value,
allow_negative_populations=True,
mode='continuous')
gillespy_model.delete_parameter(rule_variable)
gillespy_model.add_species([species])
t = []
if rule.isAssignment():
assign_value = eval(rule_string, {**eval_globals, **init_state})
postponed_evals[rule_variable] = rule_string
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
})
if rule.isRate():
gillespy_rule = gillespy2.RateRule(name=rule_name,
variable=rule_variable,
formula=rule_string)
gillespy_model.add_rate_rule(gillespy_rule)
if rule.isAlgebraic():
t.append('algebraic')
if len(t) > 0:
t[0] = t[0].capitalize()
msg = ", ".join(t)
msg += " rule"
else:
msg = "Rule"
errors.append([
"{0} '{1}' found on line '{2}' with equation '{3}'. gillespy does not support SBML Algebraic Rules"
.format(msg, rule.getId(), rule.getLine(),
libsbml.formulaToString(rule.getMath())), -5
])
def __create_diff_eqs(self, comb, model, dependencies):
'''
Helper method used to convert stochastic reaction descriptions into
differential equations, used dynamically throught the simulation.
'''
diff_eqs = OrderedDict()
rate_rules = OrderedDict()
#Initialize sample dict
for spec in model.listOfSpecies:
if spec in model.listOfRateRules:
diff_eqs[spec] = model.listOfRateRules[spec].formula
else:
diff_eqs[spec] = '0'
# loop through each det reaction and concatenate it's diff eq for each species
for reaction in comb:
factor = {dep: 0 for dep in dependencies[reaction]}
for key, value in model.listOfReactions[reaction].reactants.items(
):
if not key.constant and not key.boundary_condition:
factor[key.name] -= value
for key, value in model.listOfReactions[reaction].products.items():
if not key.constant and not key.boundary_condition:
factor[key.name] += value
for dep in dependencies[reaction]:
if factor[dep] != 0:
if model.listOfSpecies[dep].mode == 'continuous':
diff_eqs[dep] += ' + {0}*({1})'.format(
factor[dep], model.listOfReactions[reaction].
ode_propensity_function)
else:
diff_eqs[dep] += ' + {0}*({1})'.format(
factor[dep], model.listOfReactions[reaction].
propensity_function)
for spec in model.listOfSpecies:
if diff_eqs[spec] == '0':
del diff_eqs[spec]
#create a dictionary of compiled gillespy2 rate rules
for spec, rate in diff_eqs.items():
rate_rules[spec] = compile(
gillespy2.RateRule(model.listOfSpecies[spec], rate).formula,
'<string>', 'eval')
return rate_rules
def create_truncated_state_model(parameter_values=None):
model = gillespy2.Model(name="TruncatedStateModel")
S1 = gillespy2.Species(name="S1", initial_value=0, mode="discrete")
rate = gillespy2.Species(name="rate",
initial_value=0.9999,
mode="continuous")
model.add_species([S1, rate])
model.add_rate_rule(
gillespy2.RateRule(variable="rate",
formula="-1/((t+0.9999)**2)"))
model.add_reaction(
# Because S1 is a "discrete" species, our reaction will be marked "stochastic."
gillespy2.Reaction(products={S1: 1},
propensity_function="10.0*rate"))
return model
def create_diff_eqs(self, comb, model, dependencies):
diff_eqs = OrderedDict()
reactions = OrderedDict()
rate_rules = OrderedDict()
#Initialize sample dict
for reaction in comb:
for dep in dependencies[reaction]:
if dep not in diff_eqs:
diff_eqs[dep] = '0'
# loop through each det reaction and concatenate it's diff eq for each species
for reaction in comb:
factor = OrderedDict()
for dep in dependencies[reaction]:
if model.listOfSpecies[dep].mode != 'continuous':
pure_continuous = False
for dep in dependencies[reaction]:
factor[dep] = 0
for key, value in model.listOfReactions[reaction].reactants.items(
):
factor[key.name] -= value
for key, value in model.listOfReactions[reaction].products.items():
factor[key.name] += value
for dep in dependencies[reaction]:
if factor[dep] != 0:
if model.listOfSpecies[dep].mode == 'continuous':
diff_eqs[dep] += ' + {0}*({1})'.format(
factor[dep], model.listOfReactions[reaction].
ode_propensity_function)
else:
diff_eqs[dep] += ' + {0}*({1})'.format(
factor[dep], model.listOfReactions[reaction].
propensity_function)
#create a dictionary of compiled gillespy2 rate rules
for spec, rate in diff_eqs.items():
rate_rules[spec] = compile(
gillespy2.RateRule(model.listOfSpecies[spec], rate).expression,
'<string>', 'eval')
# be sure to include model rate rules
for i, rr in enumerate(model.listOfRateRules):
rate_rules[rr] = compile(model.listOfRateRules[rr].expression,
'<string>', 'eval')
return rate_rules
def test_add_bad_species_rate_rule_dict(self):
model = Example()
rule = gillespy2.RateRule(formula='sin(t)')
with self.assertRaises(ModelError):
model.add_rate_rule(rule)
def test_add_bad_expression_rate_rule_dict(self):
species2 = gillespy2.Species('test_species2', initial_value=2, mode='continuous')
rule = gillespy2.RateRule(species=species2, expression='')
with self.assertRaises(ModelError):
self.model.add_rate_rule(rule)
def test_add_bad_species_rate_rule_dict(self):
species2 = gillespy2.Species('test_species2', initial_value=2, mode='continuous')
rule = gillespy2.RateRule(formula='sin(t)')
with self.assertRaises(ModelError):
self.model.add_rate_rule(rule)
