def test_trackers():
""" test whether simple trackers can be used """
times = []
def store_time(state, t):
times.append(t)
def get_data(state):
return {"integral": state.integral}
devnull = open(os.devnull, "w")
data = trackers.DataTracker(get_data, interval=0.1)
tracker_list = [
trackers.PrintTracker(interval=0.1, stream=devnull),
trackers.CallbackTracker(store_time, interval=0.1),
None, # should be ignored
data,
]
if module_available("matplotlib"):
tracker_list.append(trackers.PlotTracker(interval=0.1, show=False))
grid = UnitGrid([16, 16])
state = ScalarField.random_uniform(grid, 0.2, 0.3)
pde = DiffusionPDE()
pde.solve(state, t_range=1, dt=0.005, tracker=tracker_list)
devnull.close()
assert times == data.times
if module_available("pandas"):
df = data.dataframe
np.testing.assert_allclose(df["time"], times)
np.testing.assert_allclose(df["integral"], state.integral)
def test_scalars():
"""test some scalar fields"""
grid = CartesianGrid([[0.1, 0.3], [-2, 3]], [3, 4])
s1 = ScalarField(grid, np.full(grid.shape, 1))
s2 = ScalarField(grid, np.full(grid.shape, 2))
assert s1.average == pytest.approx(1)
assert s1.magnitude == pytest.approx(1)
s3 = s1 + s2
assert s3.grid == grid
np.testing.assert_allclose(s3.data, 3)
s1 += s2
np.testing.assert_allclose(s1.data, 3)
s2 = FieldBase.from_state(s1.attributes, data=s1.data)
assert s1 == s2
assert s1.grid is s2.grid
attrs = ScalarField.unserialize_attributes(s1.attributes_serialized)
s2 = FieldBase.from_state(attrs, data=s1.data)
assert s1 == s2
assert s1.grid is not s2.grid
# test options for plotting images
if module_available("matplotlib"):
s1.plot(transpose=True, colorbar=True)
s3 = ScalarField(grid, s1)
assert s1 is not s3
assert s1 == s3
assert s1.grid is s3.grid
# multiplication with numpy arrays
arr = np.random.randn(*grid.shape)
np.testing.assert_allclose((arr * s1).data, (s1 * arr).data)
def test_storage_truncation(tmp_path):
""" test whether simple trackers can be used """
file = tmp_path / "test_storage_truncation.hdf5"
for truncate in [True, False]:
storages = [MemoryStorage()]
if module_available("h5py"):
storages.append(FileStorage(file))
tracker_list = [s.tracker(interval=0.01) for s in storages]
grid = UnitGrid([8, 8])
state = ScalarField.random_uniform(grid, 0.2, 0.3)
pde = DiffusionPDE()
pde.solve(state, t_range=0.1, dt=0.001, tracker=tracker_list)
if truncate:
for storage in storages:
storage.clear()
pde.solve(state, t_range=[0.1, 0.2], dt=0.001, tracker=tracker_list)
times = np.arange(0.1, 0.201, 0.01)
if not truncate:
times = np.r_[np.arange(0, 0.101, 0.01), times]
for storage in storages:
msg = f"truncate={truncate}, storage={storage}"
np.testing.assert_allclose(storage.times, times, err_msg=msg)
assert not storage.has_collection
def test_storing_collection(tmp_path):
""" test methods specific to FieldCollections in memory storage """
grid = UnitGrid([2, 2])
f1 = ScalarField.random_uniform(grid, 0.1, 0.4, label="a")
f2 = VectorField.random_uniform(grid, 0.1, 0.4, label="b")
f3 = Tensor2Field.random_uniform(grid, 0.1, 0.4, label="c")
fc = FieldCollection([f1, f2, f3])
storage_classes = {"MemoryStorage": MemoryStorage}
if module_available("h5py"):
file_path = tmp_path / "test_storage_write.hdf5"
storage_classes["FileStorage"] = functools.partial(
FileStorage, file_path)
for storage_cls in storage_classes.values():
# store some data
storage = storage_cls()
storage.start_writing(fc)
storage.append(fc, 0)
storage.append(fc, 1)
storage.end_writing()
assert storage.has_collection
assert storage.extract_field(0)[0] == f1
assert storage.extract_field(1)[0] == f2
assert storage.extract_field(2)[0] == f3
assert storage.extract_field(0)[0].label == "a"
assert storage.extract_field(0,
label="new label")[0].label == "new label"
assert storage.extract_field(0)[0].label == "a" # do not alter label
assert storage.extract_field("a")[0] == f1
assert storage.extract_field("b")[0] == f2
assert storage.extract_field("c")[0] == f3
with pytest.raises(ValueError):
storage.extract_field("nonsense")
def test_storage_copy(tmp_path):
""" test the copy function of StorageBase """
grid = UnitGrid([2])
field = ScalarField(grid)
storage_classes = {"None": None, "MemoryStorage": MemoryStorage}
if module_available("h5py"):
file_path = tmp_path / "test_storage_apply.hdf5"
storage_classes["FileStorage"] = functools.partial(
FileStorage, file_path)
s1 = MemoryStorage()
s1.start_writing(field, info={"b": 2})
s1.append(field.copy(data=np.array([0, 1])), 0)
s1.append(field.copy(data=np.array([1, 2])), 1)
s1.end_writing()
for name, storage_cls in storage_classes.items():
out = None if storage_cls is None else storage_cls()
s2 = s1.copy(out=out)
assert storage_cls is None or s2 is out
assert len(s2) == 2
np.testing.assert_allclose(s2.times, s1.times)
assert s2[0] == s1[0], name
assert s2[1] == s1[1], name
# test empty storage
s1 = MemoryStorage()
s2 = s1.copy()
assert len(s2) == 0
def test_vectors():
""" test some vector fields """
grid = CartesianGrid([[0.1, 0.3], [-2, 3]], [3, 4])
v1 = VectorField(grid, np.full((2, ) + grid.shape, 1))
v2 = VectorField(grid, np.full((2, ) + grid.shape, 2))
np.testing.assert_allclose(v1.average, (1, 1))
assert np.allclose(v1.magnitude, np.sqrt(2))
v3 = v1 + v2
assert v3.grid == grid
np.testing.assert_allclose(v3.data, 3)
v1 += v2
np.testing.assert_allclose(v1.data, 3)
# test projections
v1 = VectorField(grid)
v1.data[0, :] = 3
v1.data[1, :] = 4
for method, value in [
("min", 3),
("max", 4),
("norm", 5),
("squared_sum", 25),
("norm_squared", 25),
("auto", 5),
]:
p1 = v1.to_scalar(method)
assert p1.data.shape == grid.shape
np.testing.assert_allclose(p1.data, value)
v2 = FieldBase.from_state(v1.attributes, data=v1.data)
assert v1 == v2
assert v1.grid is v2.grid
attrs = VectorField.unserialize_attributes(v1.attributes_serialized)
v2 = FieldBase.from_state(attrs, data=v1.data)
assert v1 == v2
assert v1.grid is not v2.grid
# test dot product
v2._grid = v1.grid # make sure grids are identical
v1.data = 1
v2.data = 2
dot_op = v1.make_dot_operator()
res = ScalarField(grid, dot_op(v1.data, v2.data))
for s in (v1 @ v2, v2 @ v1, v1.dot(v2), res):
assert isinstance(s, ScalarField)
assert s.grid is grid
np.testing.assert_allclose(s.data, np.full(grid.shape, 4))
# test options for plotting images
if module_available("matplotlib"):
v1.plot(method="streamplot", transpose=True)
def test_simple_shapes(example_grid):
"""test simple scalar fields"""
pf = ScalarField.random_uniform(example_grid)
np.testing.assert_equal(pf.data.shape, example_grid.shape)
pf_lap = pf.laplace("natural")
np.testing.assert_equal(pf_lap.data.shape, example_grid.shape)
assert isinstance(pf.integral, float)
pf_c = pf.copy()
np.testing.assert_allclose(pf.data, pf_c.data)
assert pf.grid == pf_c.grid
assert pf.data is not pf_c.data
if module_available("matplotlib"):
pf.plot() # simply test whether this does not cause errors
def test_storage_write(tmp_path):
"""test simple memory storage"""
dim = 5
grid = UnitGrid([dim])
field = ScalarField(grid)
storage_classes = {"MemoryStorage": MemoryStorage}
if module_available("h5py"):
file_path = tmp_path / "test_storage_write.hdf5"
storage_classes["FileStorage"] = functools.partial(
FileStorage, file_path)
for name, storage_cls in storage_classes.items():
storage = storage_cls(info={"a": 1})
storage.start_writing(field, info={"b": 2})
field.data = np.arange(dim)
storage.append(field, 0)
field.data = np.arange(dim)
storage.append(field, 1)
storage.end_writing()
assert not storage.has_collection
np.testing.assert_allclose(storage.times, np.arange(2))
for f in storage:
np.testing.assert_array_equal(f.data, np.arange(dim))
for i in range(2):
np.testing.assert_array_equal(storage[i].data, np.arange(dim))
assert {"a": 1, "b": 2}.items() <= storage.info.items()
storage = storage_cls()
storage.clear()
for i in range(3):
storage.start_writing(field)
field.data = np.arange(dim) + i
storage.append(field, i)
storage.end_writing()
np.testing.assert_allclose(storage.times,
np.arange(3),
err_msg="storage class: " + name)
def test_storing_extract_range(tmp_path):
"""test methods specific to FieldCollections in memory storage"""
sf = ScalarField(UnitGrid([1]))
storage_classes = {"MemoryStorage": MemoryStorage}
if module_available("h5py"):
file_path = tmp_path / "test_storage_write.hdf5"
storage_classes["FileStorage"] = functools.partial(
FileStorage, file_path)
for storage_cls in storage_classes.values():
# store some data
s1 = storage_cls()
s1.start_writing(sf)
sf.data = np.array([0])
s1.append(sf, 0)
sf.data = np.array([2])
s1.append(sf, 1)
s1.end_writing()
np.testing.assert_equal(s1[0].data, 0)
np.testing.assert_equal(s1[1].data, 2)
np.testing.assert_equal(s1[-1].data, 2)
np.testing.assert_equal(s1[-2].data, 0)
with pytest.raises(IndexError):
s1[2]
with pytest.raises(IndexError):
s1[-3]
# test extraction
s2 = s1.extract_time_range()
assert s2.times == list(s1.times)
np.testing.assert_allclose(s2.data, s1.data)
s3 = s1.extract_time_range(0.5)
assert s3.times == s1.times[:1]
np.testing.assert_allclose(s3.data, s1.data[:1])
s4 = s1.extract_time_range((0.5, 1.5))
assert s4.times == s1.times[1:]
np.testing.assert_allclose(s4.data, s1.data[1:])
def test_storage_types(dtype, tmp_path):
"""test storing different types"""
grid = UnitGrid([32])
field = ScalarField.random_uniform(grid).copy(dtype=dtype)
if dtype == complex:
field += 1j * ScalarField.random_uniform(grid)
storage_classes = {"MemoryStorage": MemoryStorage}
if module_available("h5py"):
file_path = tmp_path / "test_storage_apply.hdf5"
storage_classes["FileStorage"] = functools.partial(
FileStorage, file_path)
for storage_cls in storage_classes.values():
s = storage_cls()
s.start_writing(field)
s.append(field, 0)
s.append(field, 1)
s.end_writing()
assert len(s) == 2
np.testing.assert_allclose(s.times, [0, 1])
np.testing.assert_equal(s[0].data, field.data)
np.testing.assert_equal(s[1].data, field.data)
from typing import List # @UnusedImport
import pytest
from pde.tools.misc import module_available, skipUnlessModule
from pde.visualization.movies import Movie
PACKAGE_PATH = Path(__file__).resolve().parents[2]
EXAMPLES = glob.glob(str(PACKAGE_PATH / "examples" / "*.py"))
NOTEBOOKS = glob.glob(str(
PACKAGE_PATH / "examples" / "jupyter" / "*.ipynb")) + glob.glob(
str(PACKAGE_PATH / "examples" / "tutorial" / "*.ipynb"))
SKIP_EXAMPLES: List[str] = []
if not Movie.is_available():
SKIP_EXAMPLES.extend(["make_movie_live.py", "make_movie_storage.py"])
if not module_available("napari"):
SKIP_EXAMPLES.extend(
["tracker_interactive", "show_3d_field_interactively"])
@pytest.mark.slow
@pytest.mark.no_cover
@pytest.mark.skipif(sys.platform == "win32", reason="Assumes unix setup")
@pytest.mark.parametrize("path", EXAMPLES)
def test_example(path):
""" runs an example script given by path """
# check whether this test needs to be run
if os.path.basename(path).startswith("_"):
pytest.skip("skip examples starting with an underscore")
if any(name in path for name in SKIP_EXAMPLES):
pytest.skip(f"Skip test {path}")
import glob
import os
import subprocess as sp
import sys
from pathlib import Path
from typing import List # @UnusedImport
import pytest
from pde.tools.misc import module_available
PACKAGE_PATH = Path(__file__).resolve().parents[2]
EXAMPLES = glob.glob(str(PACKAGE_PATH / "examples" / "*.py"))
SKIP_EXAMPLES: List[str] = []
if not module_available("matplotlib"):
SKIP_EXAMPLES.append("plot_emulsion.py")
@pytest.mark.no_cover
@pytest.mark.skipif(sys.platform == "win32", reason="Assumes unix setup")
@pytest.mark.parametrize("path", EXAMPLES)
def test_example(path):
""" runs an example script given by path """
if os.path.basename(path).startswith("_"):
pytest.skip("skip examples starting with an underscore")
if any(name in path for name in SKIP_EXAMPLES):
pytest.skip(f"Skip test {path}")
env = os.environ.copy()
env["PYTHONPATH"] = str(PACKAGE_PATH) + ":" + env.get("PYTHONPATH", "")
import pytest
from pde.tools.misc import module_available, skipUnlessModule
from pde.visualization.movies import Movie
PACKAGE_PATH = Path(__file__).resolve().parents[2]
EXAMPLES = glob.glob(str(PACKAGE_PATH / "examples" / "*.py"))
NOTEBOOKS = glob.glob(str(
PACKAGE_PATH / "examples" / "jupyter" / "*.ipynb")) + glob.glob(
str(PACKAGE_PATH / "examples" / "tutorial" / "*.ipynb"))
SKIP_EXAMPLES: List[str] = []
if not Movie.is_available():
SKIP_EXAMPLES.extend(["make_movie_live.py", "make_movie_storage.py"])
if not module_available("napari"):
SKIP_EXAMPLES.extend(
["tracker_interactive", "show_3d_field_interactively"])
if not module_available("h5py"):
SKIP_EXAMPLES.extend(["trajectory_io"])
@pytest.mark.slow
@pytest.mark.no_cover
@pytest.mark.skipif(sys.platform == "win32", reason="Assumes unix setup")
@pytest.mark.parametrize("path", EXAMPLES)
def test_example(path):
"""runs an example script given by path"""
# check whether this test needs to be run
if os.path.basename(path).startswith("_"):
pytest.skip("skip examples starting with an underscore")
