def test_rect_grid_2d():
"""test 2D grids"""
grid = CartesianGrid([[2], [2]], 4, periodic=True)
assert grid.get_image_data(np.zeros(grid.shape))["extent"] == [0, 2, 0, 2]
for _ in range(10):
p = np.random.randn(2)
assert np.all(grid.polar_coordinates_real(p) < np.sqrt(2))
periodic = random.choices([True, False], k=2)
grid = CartesianGrid([[4], [4]], 4, periodic=periodic)
assert grid.dim == 2
assert grid.volume == 16
np.testing.assert_array_equal(grid.discretization, np.ones(2))
assert grid.typical_discretization == 1
assert grid.polar_coordinates_real((1, 1)).shape == (4, 4)
grid = CartesianGrid([[-2, 2], [-2, 2]], [4, 8], periodic=periodic)
assert grid.dim == 2
assert grid.volume == 16
assert grid.typical_discretization == 0.75
assert grid.polar_coordinates_real((1, 1)).shape == (4, 8)
# test conversion between polar and Cartesian coordinates
c1 = grid.cell_coords
p = np.random.random(2) * grid.shape
d, a = grid.polar_coordinates_real(p, ret_angle=True)
c2 = grid.from_polar_coordinates(d, a, p)
assert np.allclose(grid.distance_real(c1, c2), 0)
def test_rect_grid_1d():
"""test 1D grids"""
grid = CartesianGrid([32], 16, periodic=False)
assert grid.dim == 1
assert grid.volume == 32
assert grid.typical_discretization == 2
np.testing.assert_array_equal(grid.discretization, np.full(1, 2))
assert grid.polar_coordinates_real(0).shape == (16, )
grid = CartesianGrid([[-16, 16]], 8, periodic=True)
assert grid.cuboid.pos == [-16]
assert grid.shape == (8, )
assert grid.dim == 1
assert grid.volume == 32
assert grid.typical_discretization == 4
assert grid.polar_coordinates_real(1).shape == (8, )
np.testing.assert_allclose(grid.normalize_point(-16 - 1e-10), 16 - 1e-10)
np.testing.assert_allclose(grid.normalize_point(-16 + 1e-10), -16 + 1e-10)
np.testing.assert_allclose(grid.normalize_point(16 - 1e-10), 16 - 1e-10)
np.testing.assert_allclose(grid.normalize_point(16 + 1e-10), -16 + 1e-10)
for periodic in [True, False]:
a, b = np.random.random(2)
grid = CartesianGrid([[a, a + b]], 8, periodic=periodic)
# test conversion between polar and Cartesian coordinates
c1 = grid.cell_coords
p = np.random.random(1) * grid.shape
d, a = grid.polar_coordinates_real(p, ret_angle=True)
c2 = grid.from_polar_coordinates(d, a, p)
assert np.allclose(grid.distance_real(c1, c2), 0)
def test_unit_rect_grid(periodic):
"""test whether the rectangular grid behaves like a unit grid in special cases"""
dim = random.randrange(1, 4)
shape = np.random.randint(2, 10, size=dim)
g1 = UnitGrid(shape, periodic=periodic)
g2 = CartesianGrid(np.c_[np.zeros(dim), shape], shape, periodic=periodic)
volume = np.prod(shape)
for g in [g1, g2]:
assert g.volume == pytest.approx(volume)
assert g.integrate(1) == pytest.approx(volume)
assert g.make_integrator()(np.ones(shape)) == pytest.approx(volume)
assert g1.dim == g2.dim == dim
np.testing.assert_array_equal(g1.shape, g2.shape)
assert g1.typical_discretization == pytest.approx(
g2.typical_discretization)
for _ in range(10):
p1, p2 = np.random.normal(scale=10, size=(2, dim))
assert g1.distance_real(p1,
p2) == pytest.approx(g2.distance_real(p1, p2))
p0 = np.random.normal(scale=10, size=dim)
np.testing.assert_allclose(g1.polar_coordinates_real(p0),
g2.polar_coordinates_real(p0))
def test_rect_grid_3d():
"""test 3D grids"""
grid = CartesianGrid([4, 4, 4], 4)
assert grid.dim == 3
assert grid.volume == 64
assert grid.typical_discretization == 1
np.testing.assert_array_equal(grid.discretization, np.ones(3))
assert grid.polar_coordinates_real((1, 1, 3)).shape == (4, 4, 4)
bounds = [[-2, 2], [-2, 2], [-2, 2]]
grid = CartesianGrid(bounds, [4, 6, 8])
assert grid.dim == 3
np.testing.assert_allclose(grid.axes_bounds, bounds)
assert grid.volume == 64
assert grid.typical_discretization == pytest.approx(0.7222222222222)
assert grid.polar_coordinates_real((1, 1, 2)).shape == (4, 6, 8)
grid = CartesianGrid([[2], [2], [2]], 4, periodic=True)
for _ in range(10):
p = np.random.randn(3)
assert np.all(grid.polar_coordinates_real(p) < np.sqrt(3))
