def test_vector_plotting_2d(transpose):
"""test plotting of 2d vector fields"""
grid = UnitGrid([3, 4])
field = VectorField.random_uniform(grid, 0.1, 0.9)
for method in ["quiver", "streamplot"]:
ref = field.plot(method=method, transpose=transpose)
field._update_plot(ref)
# test sub-sampling
grid = UnitGrid([32, 15])
field = VectorField.random_uniform(grid, 0.1, 0.9)
field.get_vector_data(transpose=transpose, max_points=7)
def test_interactive_collection_plotting():
""" test the interactive plotting """
grid = UnitGrid([3, 3])
sf = ScalarField.random_uniform(grid, 0.1, 0.9)
vf = VectorField.random_uniform(grid, 0.1, 0.9)
field = FieldCollection([sf, vf])
field.plot_interactive(viewer_args={"show": False, "close": True})
def test_vector_laplace_cart(ndim):
"""test different vector laplace operators"""
bcs = _get_random_grid_bcs(ndim, dx="uniform", periodic="random", rank=1)
field = VectorField.random_uniform(bcs.grid)
res1 = field.laplace(bcs, backend="scipy").data
res2 = field.laplace(bcs, backend="numba").data
assert res1.shape == (ndim,) + bcs.grid.shape
np.testing.assert_allclose(res1, res2)
def test_divergence_cart(ndim):
"""test different divergence operators"""
for periodic in [True, False]:
bcs = _get_random_grid_bcs(ndim, dx="uniform", periodic=periodic, rank=1)
field = VectorField.random_uniform(bcs.grid)
res1 = field.divergence(bcs, backend="scipy").data
res2 = field.divergence(bcs, backend="numba").data
np.testing.assert_allclose(res1, res2)
def test_plotting_2d():
""" test plotting of 2d vector fields """
grid = UnitGrid([3, 3])
field = VectorField.random_uniform(grid, 0.1, 0.9)
for method in ["quiver", "streamplot"]:
ref = field.plot(method=method)
field._update_plot(ref)
def test_collections():
"""test field collections"""
grid = UnitGrid([3, 4])
sf = ScalarField.random_uniform(grid, label="sf")
vf = VectorField.random_uniform(grid, label="vf")
tf = Tensor2Field.random_uniform(grid, label="tf")
fields = FieldCollection([sf, vf, tf])
assert fields.data.shape == (7, 3, 4)
assert isinstance(str(fields), str)
fields.data[:] = 0
np.testing.assert_allclose(sf.data, 0)
np.testing.assert_allclose(vf.data, 0)
np.testing.assert_allclose(tf.data, 0)
assert fields[0] is fields["sf"]
assert fields[1] is fields["vf"]
assert fields[2] is fields["tf"]
with pytest.raises(KeyError):
fields["42"]
sf.data = 1
vf.data = 1
tf.data = 1
np.testing.assert_allclose(fields.data, 1)
assert all(np.allclose(i, 12) for i in fields.integrals)
assert all(np.allclose(i, 1) for i in fields.averages)
assert np.allclose(fields.magnitudes, np.sqrt([1, 2, 4]))
assert sf.data.shape == (3, 4)
assert vf.data.shape == (2, 3, 4)
assert tf.data.shape == (2, 2, 3, 4)
c2 = FieldBase.from_state(fields.attributes, data=fields.data)
assert c2 == fields
assert c2.grid is grid
attrs = FieldCollection.unserialize_attributes(
fields.attributes_serialized)
c2 = FieldCollection.from_state(attrs, data=fields.data)
assert c2 == fields
assert c2.grid is not grid
fields["sf"] = 2.0
np.testing.assert_allclose(sf.data, 2)
with pytest.raises(KeyError):
fields["42"] = 0
fields.plot(subplot_args=[{}, {"scale": 1}, {"colorbar": False}])
def test_pde_vector_scalar():
"""test PDE with a vector and a scalar field"""
eq = PDE({"u": "vector_laplace(u) - u + gradient(v)", "v": "- divergence(u)"})
assert not eq.explicit_time_dependence
assert not eq.complex_valued
grid = grids.UnitGrid([8, 8])
field = FieldCollection(
[VectorField.random_uniform(grid), ScalarField.random_uniform(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_smoothing_collection():
""" test smoothing of a FieldCollection """
grid = UnitGrid([3, 4], periodic=[True, False])
sf = ScalarField.random_uniform(grid)
vf = VectorField.random_uniform(grid)
tf = Tensor2Field.random_uniform(grid)
fields = FieldCollection([sf, vf, tf])
sgm = 0.5 + np.random.random()
out = fields.smooth(sigma=sgm)
for i in range(3):
np.testing.assert_allclose(out[i].data, fields[i].smooth(sgm).data)
out.data = 0
fields.smooth(sigma=sgm, out=out)
for i in range(3):
np.testing.assert_allclose(out[i].data, fields[i].smooth(sgm).data)
def test_interactive_vector_plotting():
"""test the interactive plotting"""
grid = UnitGrid([3, 3])
field = VectorField.random_uniform(grid, 0.1, 0.9)
field.plot_interactive(viewer_args={"show": False, "close": True})