def test_trigger_priorities(self):
model = EventFeatures.create_base_event_model(s1=100, s2=0, rate=1.0)
event1 = gillespy2.Event(
name="ev1",
assignments=[
gillespy2.EventAssignment(variable=model.get_species('S1'),
expression="100"),
gillespy2.EventAssignment(variable=model.get_species('S2'),
expression="100"),
],
trigger=gillespy2.EventTrigger(expression="S1 < 50"),
priority="2*t*S1")
event2 = gillespy2.Event(
name="ev2",
assignments=[
gillespy2.EventAssignment(variable=model.get_species('S1'),
expression="0"),
],
trigger=gillespy2.EventTrigger(expression="S1 < 50"),
priority="t*S1")
model.add_event([event1, event2])
solver = TauHybridCSolver(model=model)
result = model.run(solver=solver)[0]
s1, s2 = result["S1"][-1], result["S2"][-1]
# If priority is working correctly, event2 should ALWAYS fire before event1.
# Proper result is S1 = 0, S2 = 100, so no further reactions are possible.
self.assertEqual(s1, 0, "Events fired in an incorrect order")
self.assertEqual(s2, 100, "Events fired in an incorrect order")
def create_event_test_model(parameter_values=None):
model = gillespy2.Model(name='Event Test Model')
model.add_species([gillespy2.Species(name='S', initial_value=0)])
model.add_parameter(
gillespy2.Parameter(name='event_tracker', expression=99))
model.add_parameter(
gillespy2.Parameter(name='event_tracker2', expression=0))
model.add_reaction(
gillespy2.Reaction(
name='r1',
products={'S': 1},
rate=model.listOfParameters['event_tracker2']))
eventTrig1 = gillespy2.EventTrigger(expression='t>=2')
event1 = gillespy2.Event(name='event1', trigger=eventTrig1)
event1.add_assignment(
gillespy2.EventAssignment(variable='event_tracker',
expression='t'))
eventTrig2 = gillespy2.EventTrigger(
expression='t >= event_tracker + 2')
event2 = gillespy2.Event(name='event2', trigger=eventTrig2)
event2.add_assignment(
gillespy2.EventAssignment(variable='event_tracker2',
expression='t'))
model.add_event([event1, event2])
return model
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 __get_events(sbml_model, gillespy_model):
for i in range(sbml_model.getNumEvents()):
event = sbml_model.getEvent(i)
gillespy_assignments = []
trigger = event.getTrigger()
delay = event.getDelay()
if delay is not None:
delay = libsbml.formulaToL3String(delay.getMath())
expression=libsbml.formulaToL3String(trigger.getMath())
expression = expression.replace('&&', ' and ').replace('||', ' or ')
initial_value = trigger.getInitialValue()
persistent = trigger.getPersistent()
use_values_from_trigger_time = event.getUseValuesFromTriggerTime()
gillespy_trigger = gillespy2.EventTrigger(expression=expression,
initial_value=initial_value, persistent=persistent)
assignments = event.getListOfEventAssignments()
for a in assignments:
# Convert Non-Constant Parameter to Species
if a.getVariable() in gillespy_model.listOfParameters:
gillespy_species = gillespy2.Species(name=a.getVariable(),
initial_value=gillespy_model.listOfParameters[a.getVariable()].expression,
mode='continuous', allow_negative_populations=True)
gillespy_model.delete_parameter(a.getVariable())
gillespy_model.add_species([gillespy_species])
gillespy_assignment = gillespy2.EventAssignment(a.getVariable(),
__get_math(a.getMath()))
gillespy_assignments.append(gillespy_assignment)
gillespy_event = gillespy2.Event(
name=event.getId(), trigger=gillespy_trigger,
assignments=gillespy_assignments, delay=delay,
use_values_from_trigger_time=use_values_from_trigger_time)
gillespy_model.add_event(gillespy_event)
def test_initial_values(self):
model = EventFeatures.create_base_event_model(s1=0, s2=100.0, rate=1.0)
event = gillespy2.Event(
name="ev1",
assignments=[
gillespy2.EventAssignment(variable=model.get_species('S1'),
expression="S2/2"),
],
trigger=gillespy2.EventTrigger(expression="S1==0",
initial_value=False))
model.add_event(event)
solver = TauHybridCSolver(model=model)
result = model.run(solver=solver)
s1, s2 = result["S1"][-1], result["S2"][-1]
self.assertAlmostEqual(s1 + s2,
150.0,
places=1,
msg="Event assignment assigned incorrect value")
self.assertGreater(s2, 100,
"Event with initial condition did not fire")
self.assertEqual(
result["S1"][0], 50,
"Event assignment with initial condition failed to fire at t=0")
def __init__(self):
gillespy2.Model.__init__(self, name='Event Test Model')
self.add_species([gillespy2.Species(name='S', initial_value=0)])
self.add_parameter(gillespy2.Parameter(name='event_tracker',
expression=99))
self.add_parameter(gillespy2.Parameter(name='event_tracker2',
expression=0))
self.add_reaction(gillespy2.Reaction(name='r1', products={'S':1},
rate=self.listOfParameters['event_tracker2']))
eventTrig1 = gillespy2.EventTrigger(expression='t>=2')
event1 = gillespy2.Event(name='event1', trigger=eventTrig1)
event1.add_assignment(gillespy2.EventAssignment(
variable='event_tracker', expression='t'))
eventTrig2 = gillespy2.EventTrigger(expression='t >= event_tracker + 2')
event2 = gillespy2.Event(name='event2', trigger=eventTrig2)
event2.add_assignment(gillespy2.EventAssignment(
variable='event_tracker2', expression='t'))
self.add_event([event1, event2])
def test_delay_trigger_persistent(self):
model = EventFeatures.create_base_event_model(s1=100, s2=0, rate=1.0)
event1 = gillespy2.Event(
name="ev1",
assignments=[
gillespy2.EventAssignment(variable=model.get_species('S1'),
expression="0"),
gillespy2.EventAssignment(variable=model.get_species('S2'),
expression="0"),
gillespy2.EventAssignment(variable=model.get_parameter('k1'),
expression="0.0")
],
trigger=gillespy2.EventTrigger(expression="S1<60 and S2<S1",
persistent=False),
delay="t+1.0")
event2 = gillespy2.Event(
name="ev2",
assignments=[
gillespy2.EventAssignment(variable=model.get_species('S1'),
expression="200"),
gillespy2.EventAssignment(variable=model.get_species('S2'),
expression="200"),
gillespy2.EventAssignment(variable=model.get_parameter('k1'),
expression="0.0"),
],
trigger=gillespy2.EventTrigger(expression="S2>90 and t<3.5",
persistent=True),
delay="1.0")
model.add_event([event1, event2])
solver = TauHybridCSolver(model=model)
result = model.run(solver=solver)[0]
s1, s2 = result["S1"][-1], result["S2"][-1]
# If delay is working correctly:
# * event1 is never triggered. event1 sets everything to 0.
# If event1 fires, event2 can never fire.
# * event2 is triggered, setting everything to 100 (and rate to 0).
self.assertNotIn(0, [s1, s2],
"Non-persistent event fired unexpectedly")
self.assertEqual(s1, 200, "Persistent event failed to fire")
self.assertEqual(s2, 200, "Persistent event failed to fire")
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_stochastic_time_dependent_event(self):
model = Example()
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 = Example()
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()
self.assertEqual(results[0].solver_name,'TauHybridSolver')
self.assertEqual(results['Sp'][-1], 1000)
def test_event_with_time_trigger(self):
model = EventFeatures.create_base_event_model(s1=0, s2=0, rate=0.0)
event = gillespy2.Event(
name="ev1",
assignments=[
gillespy2.EventAssignment(variable=model.get_species('S1'),
expression="100.0"),
gillespy2.EventAssignment(variable=model.get_parameter('k1'),
expression="1.0")
],
trigger=gillespy2.EventTrigger(expression="t>5"))
model.add_event(event)
solver = TauHybridCSolver(model=model)
result = model.run(solver=solver)[0]
s1, s2 = result["S1"][-1], result["S2"][-1]
self.assertGreater(s2, s1, "Expected S2 > S1")
self.assertGreater(s1, 0.0, "Expected S1 > 0")
self.assertAlmostEqual(s1 + s2, 100.0, places=1)
def test_use_values_from_trigger_time(self):
model = EventFeatures.create_base_event_model(s1=100, s2=0, rate=1.0)
event = gillespy2.Event(
name="ev1",
assignments=[
gillespy2.EventAssignment(variable=model.get_species('S1'),
expression="S2"),
gillespy2.EventAssignment(variable=model.get_parameter('k1'),
expression="0.0"),
],
trigger=gillespy2.EventTrigger(expression="S1 < 60"),
delay="1.5",
use_values_from_trigger_time=True)
model.add_event(event)
solver = TauHybridCSolver(model=model)
result = model.run(solver=solver)[0]
s1, s2 = result["S1"][-1], result["S2"][-1]
self.assertGreater(
s2, s1, "Event assignment did not assign values from trigger time")
def test_event_with_species_trigger(self):
model = EventFeatures.create_base_event_model(s1=100, s2=0, rate=10.0)
event = gillespy2.Event(
name="ev1",
assignments=[
gillespy2.EventAssignment(variable=model.get_species('S1'),
expression="100.0"),
gillespy2.EventAssignment(variable=model.get_parameter('k1'),
expression="0.0")
],
trigger=gillespy2.EventTrigger(expression="S1<90"))
model.add_event(event)
solver = TauHybridCSolver(model=model)
result = model.run(solver=solver)[0]
s1, s2 = result["S1"][-1], result["S2"][-1]
self.assertEqual(
s1, 100, "Expected S1 == 100 (trigger set S1 to 100 and rate to 0")
self.assertGreater(s2, 0, "Expected S2 > 0")
self.assertFalse(np.any(result["S1"] <= 90.0),
"Expected S1 > 90 for entire simulation")
