def test_polar_grid(): """test simple polar grid""" grid = PolarSymGrid(4, 8) assert grid.dim == 2 assert grid.numba_type == "f8[:]" assert grid.shape == (8, ) assert not grid.has_hole assert grid.discretization[0] == pytest.approx(0.5) assert not grid.uniform_cell_volumes np.testing.assert_array_equal(grid.discretization, np.array([0.5])) assert grid.volume == pytest.approx(np.pi * 4**2) assert grid.volume == pytest.approx(grid.integrate(1)) np.testing.assert_allclose(grid.axes_coords[0], np.linspace(0.25, 3.75, 8)) a = grid.make_operator("laplace", "auto_periodic_neumann")(np.random.random(8)) assert a.shape == (8, ) assert np.all(np.isfinite(a)) # random points c = np.random.randint(8, size=(6, 1)) p = grid.cell_to_point(c) np.testing.assert_array_equal(c, grid.point_to_cell(p)) assert grid.contains_point(grid.get_random_point()) assert grid.contains_point(grid.get_random_point(3.99)) assert "laplace" in grid.operators
def test_polar_annulus(): """test simple polar grid with a hole""" grid = PolarSymGrid((2, 4), 8) assert grid.dim == 2 assert grid.numba_type == "f8[:]" assert grid.shape == (8,) assert grid.has_hole assert grid.discretization[0] == pytest.approx(0.25) assert not grid.uniform_cell_volumes np.testing.assert_array_equal(grid.discretization, np.array([0.25])) assert grid.volume == pytest.approx(np.pi * (4**2 - 2**2)) assert grid.volume == pytest.approx(grid.integrate(1)) assert grid.radius == (2, 4) np.testing.assert_allclose(grid.axes_coords[0], np.linspace(2.125, 3.875, 8)) a = grid.make_operator("laplace", "auto_periodic_neumann")(np.random.random(8)) assert a.shape == (8,) assert np.all(np.isfinite(a)) assert grid.contains_point(grid.get_random_point(coords="cartesian")) p = grid.get_random_point(boundary_distance=1.99, coords="cartesian") assert grid.contains_point(p) # test boundary points np.testing.assert_equal(grid._boundary_coordinates(0, False), np.array([2])) np.testing.assert_equal(grid._boundary_coordinates(0, True), np.array([4]))
def test_poisson_solver_polar(): """test the poisson solver on Polar grids""" for grid in [PolarSymGrid(4, 8), PolarSymGrid([2, 4], 8)]: for bc_val in ["auto_periodic_neumann", {"value": 1}]: bcs = grid.get_boundary_conditions(bc_val) d = ScalarField.random_uniform(grid) d -= d.average # balance the right hand side sol = solve_poisson_equation(d, bcs) test = sol.laplace(bcs) msg = f"grid={grid}, bcs={bc_val}" np.testing.assert_allclose(test.data, d.data, err_msg=msg, rtol=1e-6)
def test_conservative_laplace_polar(): """test and compare the two implementation of the laplace operator""" grid = PolarSymGrid(1.5, 8) f = ScalarField.random_uniform(grid) res = f.laplace("auto_periodic_neumann") np.testing.assert_allclose(res.integral, 0, atol=1e-12)
def test_examples_scalar_polar(): """compare derivatives of scalar fields for polar grids""" grid = PolarSymGrid(1, 32) sf = ScalarField.from_expression(grid, "r**3") # gradient res = sf.gradient([{"derivative": 0}, {"derivative": 3}]) expect = VectorField.from_expression(grid, ["3 * r**2", 0]) np.testing.assert_allclose(res.data, expect.data, rtol=0.1, atol=0.1) # gradient squared expect = ScalarField.from_expression(grid, "9 * r**4") for c in [True, False]: res = sf.gradient_squared([{ "derivative": 0 }, { "derivative": 3 }], central=c) np.testing.assert_allclose(res.data, expect.data, rtol=0.1, atol=0.1) # laplace res = sf.laplace([{"derivative": 0}, {"derivative": 3}]) expect = ScalarField.from_expression(grid, "9 * r") np.testing.assert_allclose(res.data, expect.data, rtol=0.1, atol=0.1)
def test_small_annulus_polar(op_name, field): """test whether a small annulus gives the same result as a sphere""" grids = [ PolarSymGrid((0, 1), 8), PolarSymGrid((1e-8, 1), 8), PolarSymGrid((0.1, 1), 8), ] f = field.random_uniform(grids[0]) res = [ field(g, data=f.data)._apply_operator(op_name, "auto_periodic_neumann") for g in grids ] np.testing.assert_almost_equal(res[0].data, res[1].data, decimal=5) assert np.linalg.norm(res[0].data - res[2].data) > 1e-3
def test_examples_tensor_polar(): """compare derivatives of tensorial fields for polar grids""" grid = PolarSymGrid(1, 32) tf = Tensor2Field.from_expression(grid, [["r**3"] * 2] * 2) # tensor divergence res = tf.divergence([{"derivative_normal": 0}, {"value_normal": [1, 1]}]) expect = VectorField.from_expression(grid, ["3 * r**2", "5 * r**2"]) np.testing.assert_allclose(res.data, expect.data, rtol=0.1, atol=0.1)
def iter_grids(): """generator providing some test grids""" for periodic in [True, False]: yield UnitGrid([3], periodic=periodic) yield UnitGrid([3, 3, 3], periodic=periodic) yield CartesianGrid([[-1, 2], [0, 3]], [5, 7], periodic=periodic) yield CylindricalSymGrid(3, [-1, 2], [7, 8], periodic_z=periodic) yield PolarSymGrid(3, 4) yield SphericalSymGrid(3, 4)
def test_gradient_squared_polar(r_inner): """compare gradient squared operator""" grid = PolarSymGrid((r_inner, 4 * np.pi), 32) field = ScalarField.from_expression(grid, "cos(r)") 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_polar_to_cartesian(): """test conversion of polar grid to Cartesian""" expr_pol = "(1 + r**2) ** -2" expr_cart = expr_pol.replace("r**2", "(x**2 + y**2)") grid_pol = PolarSymGrid(7, 16) pf_pol = ScalarField.from_expression(grid_pol, expression=expr_pol) grid_cart = CartesianGrid([[-4, 4], [-3.9, 4.1]], [16, 16]) pf_cart1 = pf_pol.interpolate_to_grid(grid_cart) pf_cart2 = ScalarField.from_expression(grid_cart, expression=expr_cart) np.testing.assert_allclose(pf_cart1.data, pf_cart2.data, atol=0.1)
def test_grid_laplace_polar(): """test the polar implementation of the laplace operator""" grid_sph = PolarSymGrid(7, 8) grid_cart = CartesianGrid([[-5, 5], [-5, 5]], [12, 11]) a_1d = ScalarField.from_expression(grid_sph, "cos(r)") a_2d = a_1d.interpolate_to_grid(grid_cart) b_2d = a_2d.laplace("auto_periodic_neumann") b_1d = a_1d.laplace("auto_periodic_neumann") b_1d_2 = b_1d.interpolate_to_grid(grid_cart) i = slice(1, -1) # do not compare boundary points np.testing.assert_allclose(b_1d_2.data[i, i], b_2d.data[i, i], rtol=0.2, atol=0.2)
def test_grid_div_grad_polar(): """compare div grad to laplacian for polar grids""" grid = PolarSymGrid(2 * np.pi, 16) field = ScalarField.from_expression(grid, "cos(r)") a = field.laplace("derivative") b = field.gradient("derivative").divergence("value") res = ScalarField.from_expression(grid, "-sin(r) / r - cos(r)") # do not test the radial boundary points np.testing.assert_allclose(a.data[1:-1], res.data[1:-1], rtol=0.1, atol=0.1) np.testing.assert_allclose(b.data[1:-1], res.data[1:-1], rtol=0.1, atol=0.1)
def test_findiff(): """test operator for a simple polar grid""" grid = PolarSymGrid(1.5, 3) _, _, r2 = grid.axes_coords[0] assert grid.discretization == (0.5, ) s = ScalarField(grid, [1, 2, 4]) v = VectorField(grid, [[1, 2, 4], [0] * 3]) # test gradient grad = s.gradient(bc="value") np.testing.assert_allclose(grad.data[0, :], [1, 3, -6]) grad = s.gradient(bc="derivative") np.testing.assert_allclose(grad.data[0, :], [1, 3, 2]) # test divergence div = v.divergence(bc="value") np.testing.assert_allclose(div.data, [5, 17 / 3, -6 + 4 / r2]) div = v.divergence(bc="derivative") np.testing.assert_allclose(div.data, [5, 17 / 3, 2 + 4 / r2])
def test_examples_vector_polar(): """compare derivatives of vector fields for polar grids""" grid = PolarSymGrid(1, 32) vf = VectorField.from_expression(grid, ["r**3", "r**2"]) # divergence res = vf.divergence([{"derivative": 0}, {"value": 1}]) expect = ScalarField.from_expression(grid, "4 * r**2") np.testing.assert_allclose(res.data, expect.data, rtol=0.1, atol=0.1) # # vector Laplacian # res = vf.laplace([{"derivative": 0}, {"value": 1}]) # expect = VectorField.from_expression(grid, ["8 * r", "3"]) # np.testing.assert_allclose(res.data, expect.data, rtol=0.1, atol=0.1) # vector gradient res = vf.gradient([{"derivative": 0}, {"value": [1, 1]}]) expr = [["3 * r**2", "-r"], ["2 * r", "r**2"]] expect = Tensor2Field.from_expression(grid, expr) np.testing.assert_allclose(res.data, expect.data, rtol=0.1, atol=0.1)
for idx in ((1, ), (1, 2, 3), (1.5, 2), ("a", "b"), 1.0): with pytest.raises(IndexError): t1[idx] t2 = FieldBase.from_state(t1.attributes, data=t1.data) assert t1 == t2 assert t1.grid is t2.grid attrs = Tensor2Field.unserialize_attributes(t1.attributes_serialized) t2 = FieldBase.from_state(attrs, data=t1.data) assert t1 == t2 assert t1.grid is not t2.grid @pytest.mark.parametrize("grid", [UnitGrid([1, 1]), PolarSymGrid(2, 1)]) def test_tensors_transpose(grid): """test transposing tensors""" def broadcast(arr): return np.asarray(arr)[(..., ) + (np.newaxis, ) * grid.num_axes] field = Tensor2Field(grid, broadcast([[0, 1], [2, 3]])) field_T = field.transpose(label="altered") assert field_T.label == "altered" np.testing.assert_allclose(field_T.data, broadcast([[0, 2], [1, 3]])) def test_tensor_symmetrize(): """test advanced tensor calculations""" grid = CartesianGrid([[0.1, 0.3], [-2, 3]], [2, 2]) t1 = Tensor2Field(grid)