def test_ode_propensity(self):
model = Model()
rate = Parameter(name='rate', expression=0.5)
model.add_parameter(rate)
species1 = Species('A', initial_value=10)
species2 = Species('B', initial_value=10)
model.add_species([species1, species2])
r1 = Reaction(name='r1', reactants={'A': 1}, products={}, rate=rate)
r2 = Reaction(name='r2',
reactants={'A': 2},
products={'B': 1},
rate=rate)
r3 = Reaction(name='r3',
reactants={
'A': 1,
'B': 1
},
products={},
rate=rate)
r4 = Reaction(name='r4',
reactants={'A': 1},
products={},
propensity_function='t')
model.add_reaction([r1, r2, r3, r4])
self.assertEqual(model.listOfReactions['r1'].ode_propensity_function,
'rate*A')
self.assertEqual(model.listOfReactions['r2'].ode_propensity_function,
'rate*A*A')
self.assertEqual(model.listOfReactions['r3'].ode_propensity_function,
'rate*A*B')
self.assertEqual(model.listOfReactions['r4'].ode_propensity_function,
't')
def test_duplicate_parameter_names(self):
model = Model()
param1 = Parameter('A', expression=0)
param2 = Parameter('A', expression=0)
model.add_parameter(param1)
with self.assertRaises(ModelError):
model.add_parameter(param2)
def test_species_parameter_name_substrings(self):
model = Model()
rate = Parameter(name='rate', expression=1)
model.add_parameter(rate)
species1 = Species('A', initial_value=100)
species2 = Species('AA', initial_value=0)
model.add_species([species1, species2])
reaction1 = Reaction(name="reaction1",
reactants={species1: 1},
products={species2: 1},
rate=rate)
model.add_reaction(reaction1)
number_points = 11
model.timespan(np.linspace(0, 1, number_points))
from gillespy2.solvers.numpy.ssa_solver import NumPySSASolver
results = model.run(number_of_trajectories=1,
solver=NumPySSASolver,
seed=1)
self.assertTrue(len(results['time']) == number_points)
self.assertTrue(len(results[species1.name]) == number_points)
self.assertTrue(len(results[species2.name]) == number_points)
self.assertGreater(results[species1.name][0],
results[species1.name][-1])
self.assertLess(results[species2.name][0], results[species2.name][-1])
self.assertEqual(
np.sum(results[species1.name]) + np.sum(results[species2.name]),
number_points * species1.initial_value)
def create_simple_hybrid_model(parameter_values=None):
model = Model(name="Simple_Hybrid_Model")
# Species
A = Species(name='A', initial_value=0)
B = Species(name='B', initial_value=0)
model.add_species([A, B])
# Parameters
k1 = Parameter(name='k1', expression=1)
k2 = Parameter(name='k2', expression=10)
model.add_parameter([k1, k2])
# Rate Rule
rate_rule = RateRule(name='Brate', variable='B', formula="cos(t)")
model.add_rate_rule(rate_rule)
# Reactions
r1 = Reaction(name='r1',
reactants={A: 1},
products={},
propensity_function="k1*B")
r2 = Reaction(name='r2', reactants={}, products={B: 1}, rate=k2)
model.add_reaction([r1, r2])
model.timespan(numpy.linspace(0, 1, 11))
return model
def test_model_equality(self):
model1 = Model()
model2 = Model()
param1 = Parameter('A', expression=0)
model1.add_parameter(param1)
model2.add_parameter(param1)
assert model1 == model2
def test_model_inequality(self):
model1 = Model()
model2 = Model()
param1 = Parameter('A', expression=0)
param2 = Parameter('B', expression=1)
model1.add_parameter(param1)
model2.add_parameter(param2)
assert model1 != model2
def test_add_nonspecies_nonreaction_nonparameter(self):
model = Model()
species = 'nonspecies'
with self.assertRaises(ModelError):
model.add_species(species)
reaction = 'nonreaction'
with self.assertRaises(ModelError):
model.add_reaction(reaction)
parameter = 'nonparameter'
with self.assertRaises(ParameterError):
model.add_parameter(parameter)
def test_reaction_valid_reactant(self):
model = Model()
rate = Parameter(name='rate', expression=0.5)
model.add_parameter(rate)
species1 = Species('A', initial_value=0)
species2 = Species('B', initial_value=0)
model.add_species([species1, species2])
reaction1 = Reaction(name="reaction1",
reactants={'A': 1},
products={species2: 1},
rate=rate)
model.add_reaction(reaction1)
assert "reaction1" in model.listOfReactions
def test_reaction_invalid_product(self):
model = Model()
rate = Parameter(name='rate', expression=0.5)
model.add_parameter(rate)
species1 = Species('A', initial_value=0)
species2 = Species('B', initial_value=0)
model.add_species([species1, species2])
reaction1 = Reaction(name="reaction1",
reactants={species1: 1},
products={'species2': 1},
rate=rate)
with self.assertRaises(ModelError):
model.add_reaction(reaction1)
def test_no_reaction_name(self):
model = Model()
rate = Parameter(name='rate', expression=0.5)
model.add_parameter(rate)
species1 = Species('A', initial_value=0)
species2 = Species('B', initial_value=0)
model.add_species([species1, species2])
# add two reactions that has no name
reaction1 = Reaction(reactants={species1: 1},
products={species2: 1},
rate=rate)
reaction2 = Reaction(reactants={species2: 1},
products={species1: 1},
rate=rate)
model.add_reaction([reaction1, reaction2])
def test_add_reaction_dict(self):
model = Model()
rate = Parameter(name='rate', expression=0.5)
model.add_parameter(rate)
species1 = Species('A', initial_value=0)
species2 = Species('B', initial_value=0)
model.add_species([species1, species2])
reactions = {
name: Reaction(name=name,
reactants={species1: 1},
products={species2: 1},
rate=rate)
for name in ["reaction1", "reaction2"]
}
with self.assertRaises(ModelError):
model.add_reaction(reactions)
def test_run_nonsolver(self):
model = Model()
rate = Parameter(name='rate', expression=0.5)
model.add_parameter(rate)
species1 = Species(name='A', initial_value=0)
species2 = Species(name='B', initial_value=0)
model.add_species(species1)
model.add_species(species2)
reaction = Reaction(name='reaction1',
reactants={species1: 1},
products={species2: 1},
rate=rate)
with self.assertRaises(SimulationError):
results = model.run(number_of_trajectories=1,
solver='non_solver',
seed=1)
def create_oregonator(parameter_values=None):
# Superclass initialization
model = Model(name="Oregonator")
# Species
F = Species(name="F", initial_value=2)
A = Species(name="A", initial_value=250)
B = Species(name="B", initial_value=500)
C = Species(name="C", initial_value=1000)
P = Species(name="P", initial_value=0)
model.add_species([F, A, B, C, P])
# Parameters (rates)
k1 = Parameter(name="k1", expression=2.0)
k2 = Parameter(name="k2", expression=0.1)
k3 = Parameter(name="k3", expression=104)
k4 = Parameter(name="k4", expression=4e-7)
k5 = Parameter(name="k5", expression=26.0)
model.add_parameter([k1, k2, k3, k4, k5])
# Reactions
reaction1 = Reaction(name="reaction1",
reactants={
B: 1,
F: 1
},
products={
A: 1,
F: 1
},
rate=k1)
reaction2 = Reaction(name="reaction2",
reactants={
A: 1,
B: 1
},
products={P: 1},
rate=k2)
reaction3 = Reaction(name="reaction3",
reactants={
A: 1,
F: 1
},
products={
A: 2,
C: 1,
F: 1
},
rate=k3)
reaction4 = Reaction(name="reaction4",
reactants={A: 2},
products={P: 1},
rate=k4)
reaction5 = Reaction(name="reaction5",
reactants={
C: 1,
F: 1
},
products={
B: 1,
F: 1
},
rate=k5)
model.add_reaction([reaction1, reaction2, reaction3, reaction4, reaction5])
if sys.argv[1] != 'ODESolver':
model.timespan(np.linspace(0, 5, 501))
else:
model.timespan(np.linspace(0, 5, 500001))
return model
def test_problem_with_name(self):
model = Model()
numeric1 = Parameter(name='123', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(numeric1)
special1 = Parameter(name='parameter.', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(special1)
special2 = Parameter(name='parameter[', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(special2)
special3 = Parameter(name='parameter]', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(special3)
special4 = Parameter(name='parameter+', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(special4)
special5 = Parameter(name='parameter-', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(special5)
special6 = Parameter(name='parameter*', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(special6)
special7 = Parameter(name='parameter/', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(special7)
special8 = Parameter(name='parameter^', expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(special8)
reserved1 = Parameter(name="vol", expression=0.5)
with self.assertRaises(ModelError):
model.add_parameter(reserved1)
