def test_scalar_random_uniform():
""" test creating collections using scalar_random_uniform """
grid = UnitGrid([3, 4], periodic=[True, False])
fc = FieldCollection.scalar_random_uniform(2, grid, label="c", labels=["a", "b"])
assert fc.label == "c"
assert fc[0].label == "a"
assert fc[1].label == "b"
assert fc[0].grid is grid
assert fc[1].grid is grid
assert not np.allclose(fc[0].data, fc[1].data)
def test_pde_2scalar():
"""test PDE with two scalar fields"""
eq = PDE({"u": "laplace(u) - u", "v": "- u * v"})
assert not eq.explicit_time_dependence
assert not eq.complex_valued
grid = grids.UnitGrid([8])
field = FieldCollection.scalar_random_uniform(2, grid)
res_a = eq.solve(field, t_range=1, dt=0.01, backend="numpy", tracker=None)
res_b = eq.solve(field, t_range=1, dt=0.01, backend="numba", tracker=None)
res_a.assert_field_compatible(res_b)
np.testing.assert_allclose(res_a.data, res_b.data)
def test_solvers_complex(backend):
"""test solvers with a complex PDE"""
r = FieldCollection.scalar_random_uniform(2, UnitGrid([3]), labels=["a", "b"])
c = r["a"] + 1j * r["b"]
assert c.is_complex
# assume c = a + i * b
eq_c = PDE({"c": "-I * laplace(c)"})
eq_r = PDE({"a": "laplace(b)", "b": "-laplace(a)"})
res_r = eq_r.solve(r, t_range=1e-2, dt=1e-3, backend="numpy", tracker=None)
exp_c = res_r[0].data + 1j * res_r[1].data
for solver_class in [ExplicitSolver, ImplicitSolver, ScipySolver]:
solver = solver_class(eq_c, backend=backend)
controller = Controller(solver, t_range=1e-2, tracker=None)
res_c = controller.run(c, dt=1e-3)
np.testing.assert_allclose(res_c.data, exp_c, rtol=1e-3, atol=1e-3)
def test_pde_wrong_input():
""" test some wrong input """
with pytest.raises(RuntimeError):
PDE({"t": 1})
grid = grids.UnitGrid([4])
eq = PDE({"u": 1})
assert eq.expressions == {"u": "1.0"}
with pytest.raises(ValueError):
eq.evolution_rate(FieldCollection.scalar_random_uniform(2, grid))
eq = PDE({"u": 1, "v": 2})
assert eq.expressions == {"u": "1.0", "v": "2.0"}
with pytest.raises(ValueError):
eq.evolution_rate(ScalarField.random_uniform(grid))
eq = PDE({"u": "a"})
with pytest.raises(RuntimeError):
eq.evolution_rate(ScalarField.random_uniform(grid))
the recovery time scale. We implement this as a custom PDE class below.
"""
from pde import UnitGrid, FieldCollection, PDEBase
class FitzhughNagumoPDE(PDEBase):
""" FitzHugh–Nagumo model with diffusive coupling """
def __init__(self, stimulus=.5, τ=10, a=0, b=0, bc='natural'):
self.bc = bc
self.stimulus = stimulus
self.τ = τ
self.a = a
self.b = b
def evolution_rate(self, state, t=0):
v, w = state # membrane potential and recovery variable
v_t = v.laplace(bc=self.bc) + v - v**3 / 3 - w + self.stimulus
w_t = (v + self.a - self.b * w) / self.τ
return FieldCollection([v_t, w_t])
grid = UnitGrid([32, 32])
state = FieldCollection.scalar_random_uniform(2, grid)
eq = FitzhughNagumoPDE()
result = eq.solve(state, t_range=100, dt=0.01)
result.plot()
