def test_lorenz_attractor(self):
indict = open_json("lorenz_attractor.json")
shapes = _from_json_to_shapes(indict, default_config)
shape_sys = SystemOfShapes.from_shapes(shapes)
sigma, beta, rho = sympy.symbols("sigma beta rho")
assert shape_sys.A_ == sympy.Matrix([[-sigma, sigma, 0], [rho, -1, 0],
[0, 0, -beta]])
x, y, z = sympy.symbols("x y z")
assert shape_sys.c_ == sympy.Matrix([[0], [-x * z], [x * y]])
def test_inhomogeneous_solver_second_order(self):
r"""test failure to generate propagators for inhomogeneous 2nd order ODE"""
tau = 10. # [s]
parameters_dict = {sympy.Symbol("tau"): str(tau)}
x0 = 0.
x0d = 10.
shape = Shape.from_ode("x", "-1/tau**2 * x - 2/tau * x' - 1", initial_values={"x": str(x0), "x'": str(x0d)}, parameters=parameters_dict)
sys_of_shape = SystemOfShapes.from_shapes([shape], parameters=parameters_dict)
solver_dict = sys_of_shape.generate_propagator_solver()
def test_system_matrix_construction(self):
indict = open_json("system_matrix_test.json")
shapes = _from_json_to_shapes(indict, default_config)
shape_sys = SystemOfShapes.from_shapes(shapes)
sigma, beta = sympy.symbols("sigma beta")
assert shape_sys.A_ == sympy.Matrix([[-sigma, sigma, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, -beta]])
x, y, z = sympy.symbols("x y z")
assert shape_sys.c_ == sympy.Matrix([[0], [3 * z * x**2 - x * y],
[x * y]])
def test_morris_lecar(self):
indict = open_json("morris_lecar.json")
shapes, parameters = _from_json_to_shapes(indict, default_config)
shape_sys = SystemOfShapes.from_shapes(shapes, parameters=parameters)
C_m, g_Ca, g_K, g_L, E_Ca, E_K, E_L, I_ext = sympy.symbols("C_m g_Ca g_K g_L E_Ca E_K E_L I_ext")
assert shape_sys.A_ == sympy.Matrix([[sympy.parsing.sympy_parser.parse_expr("-500.0 * g_Ca / C_m - 1000.0 * g_L / C_m"), sympy.parsing.sympy_parser.parse_expr("1000.0 * E_K * g_K / C_m")],
[sympy.parsing.sympy_parser.parse_expr("0.0"), sympy.parsing.sympy_parser.parse_expr("0.0")]])
V, W = sympy.symbols("V W")
assert shape_sys.b_ == sympy.Matrix([[sympy.parsing.sympy_parser.parse_expr("500.0 * E_Ca * g_Ca / C_m + 1000.0 * E_L * g_L / C_m + 1000.0 * I_ext / C_m")],
[sympy.parsing.sympy_parser.parse_expr("0.0")]])
assert shape_sys.c_ == sympy.Matrix([[sympy.parsing.sympy_parser.parse_expr("500.0 * E_Ca * g_Ca * tanh(V / 15 + 1 / 15) / C_m - 1000.0 * V * W * g_K / C_m - 500.0 * V * g_Ca * tanh(V / 15 + 1 / 15) / C_m")],
[sympy.parsing.sympy_parser.parse_expr("-200.0 * W * cosh(V / 60) + 100.0 * cosh(V / 60) * tanh(V / 30) + 100.0 * cosh(V / 60)")]])
def test_inhomogeneous_solver_second_order_combined_system(self):
r"""test propagators generation for combined homogeneous/inhomogeneous ODEs"""
tau = 10. # [s]
E_L = -70. # [mV]
parameters_dict = {sympy.Symbol("tau"): str(tau),
sympy.Symbol("E_L"): str(E_L)}
x0 = 0.
x0d = 10.
shape_V_m = Shape.from_ode("V_m", "x / tau + (E_L - V_m)", initial_values={"V_m": "0."}, parameters=parameters_dict)
shape_I_syn1 = Shape.from_ode("x", "y", initial_values={"x": str(x0)}, parameters=parameters_dict)
shape_I_syn2 = Shape.from_ode("y", "-1/tau**2 * x - 2/tau * y", initial_values={"y": str(x0d)}, parameters=parameters_dict)
sys_of_shape = SystemOfShapes.from_shapes([shape_V_m, shape_I_syn1, shape_I_syn2], parameters=parameters_dict)
solver_dict = sys_of_shape.generate_propagator_solver()
assert set(solver_dict["state_variables"]) == set(['V_m', 'x', 'y'])
def test_inhomogeneous_simultaneous(self):
U = .2
tau = 5. # [s]
x0 = 0.
parameters_dict = {sympy.Symbol("U"): str(U),
sympy.Symbol("tau1"): str(tau),
sympy.Symbol("tau2"): str(tau)}
shape_x = Shape.from_ode("x", "(U - x) / tau1", initial_values={"x": str(x0)}, parameters=parameters_dict)
shape_y = Shape.from_ode("y", "(1 - y) / tau2", initial_values={"y": str(x0)}, parameters=parameters_dict)
sys_of_shape = SystemOfShapes.from_shapes([shape_x, shape_y], parameters=parameters_dict)
print(sys_of_shape.reconstitute_expr())
solver_dict = sys_of_shape.generate_propagator_solver()
solver_dict["parameters"] = parameters_dict
print(solver_dict)
analytic_integrator = AnalyticIntegrator(solver_dict)
analytic_integrator.set_initial_values({"x": str(x0), "y": str(x0)})
analytic_integrator.reset()
dt = 1.
actual_x = []
actual_y = []
correct_x = []
correct_y = []
cur_x = x0
cur_y = x0
timevec = np.arange(0., 100., dt)
kernel = np.exp(-dt / tau)
for step, t in enumerate(timevec):
state_x = analytic_integrator.get_value(t)["x"]
state_y = analytic_integrator.get_value(t)["y"]
actual_x.append(state_x)
actual_y.append(state_y)
correct_x.append(cur_x)
correct_y.append(cur_y)
cur_x = U + kernel * (cur_x - U)
cur_y = 1 + kernel * (cur_y - 1)
np.testing.assert_allclose(correct_x, actual_x)
np.testing.assert_allclose(correct_y, actual_y)
def test_inhomogeneous_solver(self, ode_definition):
U = .2
if ode_definition == "(1 - x) / tau":
U = 1.
tau = 5. # [s]
x0 = 0.
parameters_dict = {sympy.Symbol("U"): str(U),
sympy.Symbol("tau"): str(tau)}
shape = Shape.from_ode("x", ode_definition, initial_values={"x": str(x0)}, parameters=parameters_dict)
assert not shape.is_homogeneous()
assert shape.is_lin_const_coeff()
sys_of_shape = SystemOfShapes.from_shapes([shape], parameters=parameters_dict)
print(sys_of_shape.reconstitute_expr())
solver_dict = sys_of_shape.generate_propagator_solver()
solver_dict["parameters"] = parameters_dict
print(solver_dict)
analytic_integrator = AnalyticIntegrator(solver_dict)
analytic_integrator.set_initial_values({"x": str(x0)})
analytic_integrator.reset()
dt = 1.
actual = []
correct = []
cur_x = x0
timevec = np.arange(0., 100., dt)
kernel = np.exp(-dt / tau)
for step, t in enumerate(timevec):
state_ = analytic_integrator.get_value(t)["x"]
actual.append(state_)
correct.append(cur_x)
cur_x = U + kernel * (cur_x - U)
np.testing.assert_allclose(correct, actual)
def test_morris_lecar(self):
indict = open_json("morris_lecar.json")
shapes = _from_json_to_shapes(indict, default_config)
shape_sys = SystemOfShapes.from_shapes(shapes)
C_m, g_Ca, g_K, g_L, E_Ca, E_K, E_L, I_ext = sympy.symbols(
"C_m g_Ca g_K g_L E_Ca E_K E_L I_ext")
assert shape_sys.A_ == sympy.Matrix([[
-500.0 * g_Ca / C_m - 1000.0 * g_L / C_m, 1000.0 * E_K * g_K / C_m
], [0.0, 0.0]])
V, W = sympy.symbols("V W")
assert shape_sys.c_ == sympy.Matrix(
[[
500.0 * E_Ca * g_Ca * sympy.tanh(V / 15 + sympy.S("1/15")) /
C_m + 500.0 * E_Ca * g_Ca / C_m + 1000.0 * E_L * g_L / C_m +
1000.0 * I_ext / C_m - 1000.0 * V * W * g_K / C_m -
500.0 * V * g_Ca * sympy.tanh(V / 15 + sympy.S("1/15")) / C_m
],
[
-200.0 * W * sympy.cosh(V / 60) +
100.0 * sympy.cosh(V / 60) * sympy.tanh(V / 30) +
100.0 * sympy.cosh(V / 60)
]])