def test_null_timeout(self):
model = create_decay()
species = gillespy2.Species('test_species', initial_value=1)
model.add_species([species])
solver = TauHybridSolver(model=model)
results = solver.run()
self.assertTrue(len(results) > 0)
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_file_with_directory_name_exists(self):
with self.assertRaises(DirectoryError):
temp = tempfile.NamedTemporaryFile()
model = create_decay()
solverSSAC = SSACSolver(model, temp.name)
solverODEC = ODECSolver(model, temp.name)
solverTAUC = TauLeapingCSolver(model, temp.name)
solverHYBC = TauHybridCSolver(model, temp.name)
def test_ensure_continuous_dynamic_timeout_warning(self):
model = create_decay()
species1 = gillespy2.Species('test_species1',
initial_value=1,
mode='dynamic')
model.add_species(species1)
with self.assertLogs('GillesPy2', level='WARN'):
solver = TauHybridSolver(model=model)
results = model.run(solver=solver, timeout=1)
def test_ensure_hybrid_continuous_species(self):
model = create_decay()
species1 = gillespy2.Species('test_species1',
initial_value=1,
mode='continuous')
model.add_species(species1)
results = model.run()
valid_solvers = ('TauHybridSolver', 'TauHybridCSolver')
self.assertIn(results[0].solver_name, valid_solvers)
def test_StochML_from_and_to_model(self):
model = create_decay()
stochml = StochMLDocument.from_model(model)
stochml_model = stochml.to_model('model')
stochml_model.timespan(model.tspan)
ode_solver = ODESolver(model=stochml_model)
stochml_model.run(solver=ode_solver)
ssa_solver = NumPySSASolver(model=stochml_model)
stochml_model.run(solver=ssa_solver)
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 test_model_run_with_both_increment_and_timespan(self):
model = create_decay()
try:
model.run(increment=4)
except SimulationError as e:
return
self.fail("""
Failed while testing Model.run() behavior when both `timespan` and `increment` are set.
""")
def test_add_assignment_rule(self):
model = create_decay()
species = gillespy2.Species('test_species4', initial_value=1)
rule = gillespy2.AssignmentRule(name='ar1',
variable=species.name,
formula='2')
model.add_species([species])
model.add_assignment_rule([rule])
results = model.run()
self.assertEquals(results[species.name][0], 2)
self.assertEquals(results[species.name][-1], 2)
self.assertEqual(results[0].solver_name, 'TauHybridSolver')
def old_check_cpp_support(self):
try:
model = create_decay()
solver = SSACSolver(model=model)
results = model.run(solver=solver, cpp_support=True)
return True
except Exception as e:
from gillespy2.core import log
log.warn('Unable to use C++ optimized SSA: {0}. The performance of ' \
'this package can be significantly increased if you install/configure GCC on ' \
'this machine.'.format(e))
return False
class TestVariableSolvers(unittest.TestCase):
model = create_decay()
solverSSAC = SSACSolver(model, variable=True)
solverODEC = ODECSolver(model, variable=True)
solverTAUC = TauLeapingCSolver(model, variable=True)
solverHYBC = TauHybridCSolver(model, variable=True)
solverlist = [solverSSAC, solverODEC, solverTAUC, solverHYBC]
def test_create(self):
model = create_decay()
solverSSAC = SSACSolver(model)
solverODEC = ODECSolver(model)
solverTAUC = TauLeapingCSolver(model)
solverHYBC = TauHybridCSolver(model)
def test_file_with_directory_name_exists(self):
with self.assertRaises(DirectoryError):
temp = tempfile.NamedTemporaryFile()
model = create_decay()
solverSSAC = SSACSolver(model, temp.name)
solverODEC = ODECSolver(model, temp.name)
solverTAUC = TauLeapingCSolver(model, temp.name)
solverHYBC = TauHybridCSolver(model, temp.name)
def test_run_example_precompiled(self):
for solver in self.solverlist:
results = self.model.run(solver=solver)
def test_change_species(self):
initial_value = self.model.listOfSpecies['Sp'].initial_value
for solver in self.solverlist:
results = self.model.run(solver=solver, variables={'Sp': 3})
with self.subTest(msg='Test changed species simulation'):
self.assertEqual(results['Sp'][0], 3)
with self.subTest(msg='Test changed species model integrity'):
self.assertEqual(self.model.listOfSpecies['Sp'].initial_value,
initial_value)
def test_change_parameter(self):
initial_expression = self.model.listOfParameters['k1'].expression
for solver in self.solverlist:
results = self.model.run(solver=solver, variables={'k1': 0})
with self.subTest(msg='Test changed parameter simulation'):
self.assertEqual(results['Sp'][-1], results['Sp'][0])
with self.subTest(msg='Test changed parameter model integrity'):
self.assertEqual(self.model.listOfParameters['k1'].expression,
initial_expression)
def test_invalid_variable(self):
with self.assertRaises(SimulationError):
for solver in self.solverlist:
results = self.model.run(solver=solver,
variables={'foobar': 0})
def test_math_name_overlap(self):
model = create_decay()
gamma = gillespy2.Species('gamma', initial_value=2, mode='continuous')
model.add_species([gamma])
k2 = gillespy2.Parameter(name='k2', expression=1)
model.add_parameter([k2])
gamma_react = gillespy2.Reaction(name='gamma_react',
reactants={'gamma': 1},
products={},
rate=k2)
model.add_reaction([gamma_react])
solver = TauHybridSolver(model=model)
model.run(solver=solver)
def test_add_stochastic_time_dependent_event(self):
model = create_decay()
model.listOfSpecies['Sp'].mode = 'discrete'
eventTrig = gillespy2.EventTrigger(
expression='t >= 10',
initial_value=True,
)
event1 = gillespy2.Event(name='event1', trigger=eventTrig)
ea1 = gillespy2.EventAssignment(variable='Sp', expression='1000')
ea2 = gillespy2.EventAssignment(variable='k1', expression='0')
event1.add_assignment([ea1, ea2])
model.add_event(event1)
results = model.run()
self.assertEqual(results['Sp'][-1], 1000)
def test_add_continuous_species_dependent_event(self):
model = create_decay()
model.listOfSpecies['Sp'].mode = 'continuous'
eventTrig = gillespy2.EventTrigger(
expression='Sp <= 90',
initial_value=True,
)
event1 = gillespy2.Event(name='event1', trigger=eventTrig)
ea1 = gillespy2.EventAssignment(variable='Sp', expression='1000')
ea2 = gillespy2.EventAssignment(variable='k1', expression='0')
event1.add_assignment([ea1, ea2])
model.add_event(event1)
results = model.run()
valid_solvers = ('TauHybridSolver', 'TauHybridCSolver')
self.assertIn(results[0].solver_name, valid_solvers)
self.assertEqual(results['Sp'][-1], 1000)
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_run_example(self):
model = create_decay()
solver = ODESolver(model=model)
for i in [1, self.number_of_trajectories]:
for label in [True, False]:
with self.subTest(number_of_trajectories=i, show_labels=label):
if i > 1:
results = model.run(solver=solver,
number_of_trajectories=i)
self.assertEqual(len(results), i)
else:
results = model.run(solver=solver,
number_of_trajectories=i)
if not label:
results = results.to_array()
if i > 1 or not label:
for result in results[1:]:
if label:
self.assertEqual(results[0], result)
else:
self.assertTrue(
np.array_equal(results[0], result))
def test_run_example__with_tspan_only(self):
model = create_decay()
solver = SSACSolver(model=model)
results = solver.run()
def test_run_example__with_tspan_and_increment(self):
with self.assertRaises(SimulationError):
model = create_decay()
solver = SSACSolver(model=model)
results = solver.run(increment=0.2)
def test_file_with_directory_name_exists(self):
with self.assertRaises(DirectoryError):
temp = tempfile.NamedTemporaryFile()
model = create_decay()
solver = SSACSolver(model, temp.name)
def test_run_example(self):
model = create_decay()
solver = SSACSolver(model=model)
results = model.run(solver=solver)
def setUp(self):
self.model = create_decay()
self.solver = ODECSolver(self.model)
self.model_no_tspan = create_decay_no_tspan()
self.solver_no_tspan = ODECSolver(self.model_no_tspan)
def test_create(self):
model = create_decay()
solver = SSACSolver(model)
def test_create(self):
model = create_decay()
solverSSAC = SSACSolver(model)
solverODEC = ODECSolver(model)
solverTAUC = TauLeapingCSolver(model)
solverHYBC = TauHybridCSolver(model)
def test_add_function_definition(self):
model = create_decay()
funcdef = gillespy2.FunctionDefinition(name='fun', function='Sp+1')
model.add_function_definition(funcdef)
results = model.run()
self.assertEqual(results[0].solver_name, 'TauHybridSolver')
def test_create(self):
model = create_decay()
solver = TauLeapingCSolver(model)
def setUp(self):
self.model = create_decay()
self.model_no_tspan = create_decay_no_tspan()
self.solver = TauLeapingSolver(model=self.model)
self.solver_no_tspan = TauLeapingSolver(model=self.model_no_tspan)
def test_run_example_precompiled(self):
model = create_decay()
solver = TauLeapingCSolver(model=model)
results = model.run(solver=solver)
def setUp(self):
self.model = create_decay()
self.solver = NumPySSASolver(model=self.model)
self.model_no_tspan = create_decay_no_tspan()
self.solver_no_tspan = NumPySSASolver(model=self.model_no_tspan)
def test_extraneous_args(self):
for solver in self.solvers:
with self.subTest(solver=solver.name), self.assertLogs('GillesPy2', level='WARN'):
model = create_decay()
solver = solver(model=model)
model.run(solver=solver, nonsense='ABC')
