def test_gradient_squared():
""" compare gradient squared operator """
grid = CylindricalGrid(2 * np.pi, [0, 2 * np.pi], 64)
field = ScalarField.random_harmonic(grid, modes=1)
s1 = field.gradient("natural").to_scalar("squared_sum")
s2 = field.gradient_squared("natural", central=True)
np.testing.assert_allclose(s1.data, s2.data, rtol=0.2, atol=0.2)
s3 = field.gradient_squared("natural", central=False)
np.testing.assert_allclose(s1.data, s3.data, rtol=0.2, atol=0.2)
assert not np.array_equal(s2.data, s3.data)
def test_gradient_squared(r_inner):
"""compare gradient squared operator"""
grid = SphericalSymGrid((r_inner, 5), 64)
field = ScalarField.random_harmonic(grid, modes=1)
s1 = field.gradient("auto_periodic_neumann").to_scalar("squared_sum")
s2 = field.gradient_squared("auto_periodic_neumann", central=True)
np.testing.assert_allclose(s1.data, s2.data, rtol=0.1, atol=0.1)
s3 = field.gradient_squared("auto_periodic_neumann", central=False)
np.testing.assert_allclose(s1.data, s3.data, rtol=0.1, atol=0.1)
assert not np.array_equal(s2.data, s3.data)
def test_gradient_squared(dim):
""" compare gradient squared operator """
grid = CartesianGrid(
[[0, 2 * np.pi]] * dim,
shape=np.random.randint(30, 35, dim),
periodic=np.random.choice([False, True], dim),
)
field = ScalarField.random_harmonic(grid, modes=1)
s1 = field.gradient("natural").to_scalar("squared_sum")
s2 = field.gradient_squared("natural", central=True)
np.testing.assert_allclose(s1.data, s2.data, rtol=0.1, atol=0.1)
s3 = field.gradient_squared("natural", central=False)
np.testing.assert_allclose(s1.data, s3.data, rtol=0.2, atol=0.2)
assert not np.array_equal(s2.data, s3.data)
def test_make_derivative(ndim, axis):
""" test the make derivative function """
periodic = random.choice([True, False])
grid = CartesianGrid([[0, 6 * np.pi]] * ndim, 16, periodic=periodic)
field = ScalarField.random_harmonic(grid, modes=1, axis_combination=np.add)
bcs = grid.get_boundary_conditions("natural")
grad = field.gradient(bcs)
for method in ["central", "forward", "backward"]:
msg = f"method={method}, periodic={periodic}"
diff = ops._make_derivative(bcs, axis=axis, method=method)
np.testing.assert_allclose(grad.data[axis],
diff(field.data),
atol=0.1,
rtol=0.1,
err_msg=msg)
def test_make_derivative2(ndim, axis):
"""test the _make_derivative2 function"""
periodic = random.choice([True, False])
grid = CartesianGrid([[0, 6 * np.pi]] * ndim, 16, periodic=periodic)
field = ScalarField.random_harmonic(grid, modes=1, axis_combination=np.add)
bcs = grid.get_boundary_conditions("auto_periodic_neumann")
grad = field.gradient(bcs)[axis]
grad2 = grad.gradient(bcs)[axis]
diff = ops._make_derivative2(grid, axis=axis)
res = field.copy()
res.data[:] = 0
field.set_ghost_cells(bcs)
diff(field._data_full, out=res.data)
np.testing.assert_allclose(grad2.data, res.data, atol=0.1, rtol=0.1)
def test_make_derivative(ndim, axis):
"""test the _make_derivative function"""
periodic = random.choice([True, False])
grid = CartesianGrid([[0, 6 * np.pi]] * ndim, 16, periodic=periodic)
field = ScalarField.random_harmonic(grid, modes=1, axis_combination=np.add)
bcs = grid.get_boundary_conditions("auto_periodic_neumann")
grad = field.gradient(bcs)
for method in ["central", "forward", "backward"]:
msg = f"method={method}, periodic={periodic}"
diff = ops._make_derivative(grid, axis=axis, method=method)
res = field.copy()
res.data[:] = 0
field.set_ghost_cells(bcs)
diff(field._data_full, out=res.data)
np.testing.assert_allclose(
grad.data[axis], res.data, atol=0.1, rtol=0.1, err_msg=msg
)
"""
Stochastic simulation
=====================
This example illustrates how a stochastic simulation can be done.
"""
from pde import (KPZInterfacePDE, UnitGrid, ScalarField, MemoryStorage,
plot_kymograph)
grid = UnitGrid([64]) # generate grid
state = ScalarField.random_harmonic(grid) # generate initial condition
eq = KPZInterfacePDE(noise=1) # define the SDE
storage = MemoryStorage()
eq.solve(state, t_range=10, dt=0.01, tracker=storage.tracker(0.5))
plot_kymograph(storage)
