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")