def test_parameter_set_parameter_update(self):
p = {"p1":1}
p_update = mb.parameters.ParameterSet({"p2":2})
m = mb.Model(p)
m.par.update(p_update)
self.assertEqual(m.par.p1, p["p1"])
self.assertEqual(m.par.p2, p_update.p2)
def test_dictionary_parameter_update(self):
p = {"p1":1}
p_update = {"p2":2}
m = mb.Model(p)
m.par.update(p_update)
self.assertEqual(m.par.p1, p["p1"])
self.assertEqual(m.par.p2, p_update["p2"])
def test_compound_ids_multiple_compounds(self):
m = mb.Model()
m.set_cpds(["X", "Y"])
self.assertEqual(m.cpdIdDict["X"], 0)
self.assertEqual(m.cpdIds()["X"], 0)
self.assertEqual(m.cpdIdDict["Y"], 1)
self.assertEqual(m.cpdIds()["Y"], 1)
def test_stoichiometries_two_compounds_two_reactions(self):
m = mb.Model({"k":1})
m.set_cpds(["X", "Y"])
m.set_rate("v0", lambda p: p.k)
m.set_rate("v1", lambda p: p.k)
m.set_stoichiometry("v0", {"X":1})
m.set_stoichiometry("v1", {"X":-1, "Y":1})
self.assertEqual(m.stoichiometries, {'v0': {'X': 1}, 'v1': {'X': -1, 'Y': 1}})
def test_full_concentration_vector_two_variables(self):
m = mb.Model()
m.set_cpds(["X", "Y"])
m.add_reaction(
"v0",
lambda p, x: x,
{"X":1},
"X")
m.add_algebraicModule(
lambda p, x: x[0] * x[1],
"mod1",
["X", "Y"],
["Z"])
self.assertTrue(all(m.fullConcVec(np.array([1, 1])) == np.array([1, 1, 1])))
def test_full_concentration_vector_one_cpd_two_derived_variables_tuple(self):
m = mb.Model()
m.set_cpds(["X"])
m.add_reaction(
"v0",
lambda p, x: x,
{"X":1},
"X")
m.add_algebraicModule(
lambda p, x: (x, x),
"mod1",
["X"],
["Y", "Z"])
self.assertTrue(all(m.fullConcVec(np.array([1])) == np.array([1, 1, 1])))
def test_integration_one_variable(self):
"""Test basic exponential decay
dxdt = - x
Solution: x(t) = exp(-t)
"""
m = mb.Model()
m.set_cpds(["x"])
m.set_rate('v0', lambda p, x: -x, "x")
m.set_stoichiometry("v0", {"x":1})
s = mb.Simulate(m)
# Simulate 10 time units
t = 10
y = s.timeCourse(np.linspace(0,t,10),np.ones(1))
self.assertTrue(np.isclose(y[-1][0], np.exp(-t)))
def test_full_concentration_vector_type_error_list(self):
m = mb.Model()
m.set_cpds(["X"])
m.add_reaction(
"v0",
lambda p, x: x,
{"X":1},
"X")
m.add_algebraicModule(
lambda p, x: x,
"mod1",
["X"],
["Y"])
with self.assertRaises(TypeError):
m.fullConcVec([1])
def test_find_steady_state(self):
"""Simple two variable integration test
-> X -> Y ->
Steady-state solution:
x = k0 / k1
y = k0 / k2
"""
from modelbase.analysis import findSteadyState
m = mb.Model({"k0":1, "k1":2, "k2": 4})
m.set_cpds(["x", "y"])
m.set_rate('v0', lambda p: p.k0)
m.set_rate('v1', lambda p, x: p.k1 * x, "x")
m.set_rate('v2', lambda p, y: p.k2 * y, "y")
m.set_stoichiometry("v0", {"x":1})
m.set_stoichiometry("v1", {"x":-1, "y":1})
m.set_stoichiometry("v2", {"y":-1})
x, y = findSteadyState(m, np.ones(2))
self.assertTrue(np.isclose(x, m.par.k0 / m.par.k1))
self.assertTrue(np.isclose(y, m.par.k0 / m.par.k2))
def test_integration_two_variables(self):
"""Simple two variable integration test
-> X -> Y ->
Steady-state solution:
x = k0 / k1
y = k0 / k2
"""
m = mb.Model({"k0":1, "k1":2, "k2": 4})
m.set_cpds(["x", "y"])
m.set_rate('v0', lambda p: p.k0)
m.set_rate('v1', lambda p, x: p.k1 * x, "x")
m.set_rate('v2', lambda p, y: p.k2 * y, "y")
m.set_stoichiometry("v0", {"x":1})
m.set_stoichiometry("v1", {"x":-1, "y":1})
m.set_stoichiometry("v2", {"y":-1})
s = mb.Simulate(m)
# Assume steady state after 100 time units
y = s.timeCourse(np.linspace(0,100,10), np.ones(2))
self.assertTrue(np.isclose(y[-1][0], m.par.k0 / m.par.k1))
self.assertTrue(np.isclose(y[-1][1], m.par.k0 / m.par.k2))
def test_set_stoichiometry_stDict_type_error_set(self):
m = mb.Model({"k":1})
m.set_cpds(["X"])
m.set_rate("v0", lambda p: p.k)
with self.assertRaises(TypeError):
m.set_stoichiometry("v0", {"X"})
def test_compound_ids_empty(self):
m = mb.Model()
m.set_cpds([])
self.assertEqual(m.cpdIdDict, {})
self.assertEqual(m.cpdIds(), {})
def test_add_cpds_value_error_double_compounds(self):
m = mb.Model()
with self.assertRaises(ValueError):
m.add_cpds(["X", "X"])
def test_type_error_parameter_init_set(self):
with self.assertRaises(TypeError):
m = mb.Model({"a"})
def test_compound_ids_one_compound(self):
m = mb.Model()
m.set_cpds(["X"])
self.assertEqual(m.cpdIdDict["X"], 0)
self.assertEqual(m.cpdIds()["X"], 0)
def test_algebraic_module_assembly_one_derived_var(self):
m = mb.Model()
m.set_cpds(["X"])
m.add_algebraicModule(lambda p, x: x, "mod1", ["X"], ["Y"])
self.assertEqual(m.allCpdNames(), ['X', 'Y'])
def test_algebraic_module_assembly_two_derived_compounds(self):
m = mb.Model()
m.set_cpds(["X"])
m.add_algebraicModule(lambda p, x: (x, x), "mod1", ["X"], ["Y", "Z"])
self.assertEqual(m.allCpdNames(), ["X", "Y", "Z"])
def test_add_cpds_list_two_compounds(self):
m = mb.Model()
m.add_cpds(["X", "Y"])
self.assertEqual(m.cpdNames, ["X", "Y"])
def test_add_reaction_v_type_error_rate_name_set(self):
m = mb.Model()
m.set_cpds(["X"])
with self.assertRaises(TypeError):
m.add_reaction_v({"a"}, lambda x: x, {"X":1}, "X")
def test_set_rate_type_error_rate_name_list(self):
m = mb.Model()
with self.assertRaises(TypeError):
m.set_rate([], lambda x: x)
def test_dictionary_parameter_init(self):
m = mb.Model()
p = {"p1": 1}
m = mb.Model(p)
self.assertEqual(m.par.p1, p["p1"])
def test_set_ratev_type_error_rate_name_set(self):
m = mb.Model()
with self.assertRaises(TypeError):
m.set_ratev({"a"}, lambda x: x)
def test_parameter_set_parameter_init(self):
m = mb.Model()
p = mb.parameters.ParameterSet({"p1":1})
m = mb.Model(p)
self.assertEqual(m.par.p1, p.p1)
def test_set_ratev_rate_name_str(self):
m = mb.Model()
m.set_ratev("v1", lambda x: x)
self.assertTrue("v1" in m.rateFn)
def test_type_error_parameter_update_set(self):
m = mb.Model()
with self.assertRaises(TypeError):
m.par.update({"a"})
def test_stoichiometries_one_compound_one_reaction(self):
m = mb.Model({"k":1})
m.set_cpds(["X"])
m.set_rate("v0", lambda p: p.k)
m.set_stoichiometry("v0", {"X":1})
self.assertEqual(m.stoichiometries, {'v0': {'X': 1}})
def test_type_error_parameter_init_list_empty(self):
m = mb.Model()
self.assertTrue(isinstance(m.par, mb.parameters.ParameterSet))
def test_type_error_parameter_update_list_empty(self):
m = mb.Model()
with self.assertRaises(TypeError):
m.par.update(None)
with self.assertRaises(TypeError):
m.par.update()
import modelbase
#import modelbase.algebraicModule
import matplotlib.pyplot as plt
import numpy as np
print("Example 2 started...")
# define slow variable A
cl = ['A']
p = {'v0': 1, 'k2': 0.1, 'K': 5}
# instantiate model as AlgmModel (because it uses an algebraic module)
m = modelbase.Model(p)
m.set_cpds(cl)
# this function defines the algebraic module. It accepts as first argument
# the parameters, then the slow-changing variable
# output are the two derived variables X and Y
def feq(par, y):
return np.array([y[0] / (1 + par.K), y[0] * par.K / (1 + par.K)])
# define the algebraic module object
#eqm = modelbase.algebraicModule.AlgebraicModule({'K':5},feq)
# add it to the model by specifying the names of the variables
m.add_algebraicModule(feq, 'rapidEq', ['A'], ['X', 'Y'])
def test_add_cpds_empty_list(self):
m = mb.Model()
m.add_cpds([])
self.assertEqual(m.cpdNames, [])
