def test_helmholtz_single_layer_potential_p1_complex_coeffs( default_parameters, helpers, device_interface, precision): """Test Helmholtz slp potential with p1 basis and complex coeffs.""" from bempp.api import function_space from bempp.api import GridFunction from bempp.api.operators.potential.helmholtz import single_layer grid = helpers.load_grid("sphere") space = function_space(grid, "P", 1) data = helpers.load_npz_data("helmholtz_single_layer_potential_p1") points = data["points"] coefficients = _np.random.rand( space.global_dof_count) + 1j * _np.random.rand(space.global_dof_count) fun = GridFunction(space, coefficients=coefficients) fun_real = GridFunction(space, coefficients=_np.real(coefficients)) fun_complex = GridFunction(space, coefficients=_np.imag(coefficients)) op = single_layer( space, points, WAVENUMBER, parameters=default_parameters, precision=precision, device_interface=device_interface, ) expected = op.evaluate(fun_real) + 1j * op.evaluate(fun_complex) actual = op.evaluate(fun) _np.testing.assert_allclose(actual, expected, rtol=helpers.default_tolerance(precision))
def test_helmholtz_single_layer_potential_p1(default_parameters, helpers, device_interface, precision): """Test Helmholtz slp potential with p1 basis.""" from bempp.api import function_space from bempp.api import GridFunction from bempp.api.operators.potential.helmholtz import single_layer grid = helpers.load_grid("sphere") space = function_space(grid, "P", 1) data = helpers.load_npz_data("helmholtz_single_layer_potential_p1") coefficients = data["vec"] points = data["points"] expected = data["result"] fun = GridFunction(space, coefficients=coefficients) actual = single_layer( space, points, WAVENUMBER, parameters=default_parameters, precision=precision, device_interface=device_interface, ).evaluate(fun) _np.testing.assert_allclose(actual, expected, rtol=helpers.default_tolerance(precision))
def plot_me(points): from bempp.api.operators.potential import helmholtz as helmholtz_potential slp_pot=helmholtz_potential.single_layer(bempp_space,points,k) dlp_pot=helmholtz_potential.double_layer(trace_space,points,k) output = incident_wave(points.T) output += dlp_pot.evaluate(g_soln)[0] output -= slp_pot.evaluate(g_n_soln)[0] return output
def result (points): from bempp.api.operators.potential import helmholtz as helmholtz_potential slp_pot=helmholtz_potential.single_layer(piecewise_lin_space, points, k) dlp_pot=helmholtz_potential.double_layer(piecewise_lin_space, points, k) res = 1j * muD * slp_pot.evaluate(w_fun) - dlp_pot.evaluate(w_fun) return res
def result (points): from bempp.api.operators.potential import helmholtz as helmholtz_potential slp_pot=helmholtz_potential.single_layer(piecewise_lin_space, points, k) dlp_pot=helmholtz_potential.double_layer(piecewise_lin_space, points, k) res = 1j * muD * slp_pot.evaluate(w_fun) - dlp_pot.evaluate(w_fun) return res[0]
points = np.vstack( (plot_grid[0].ravel(), plot_grid[1].ravel(), np.zeros(plot_grid[0].size))) u_evaluated = np.zeros(points.shape[1], dtype=np.complex128) u_evaluated[:] = np.nan # This will generate a grid of points in the $x$-$y$ plane. # # Then we create a single layer potential operator and use it to evaluate the solution at the evaluation points. The variable ``idx`` allows to compute the solution only at points located outside the unit circle of the plane. We use a single layer potential operator to evaluate the solution at the observation points. # In[10]: x, y, z = points idx = np.sqrt(x**2 + y**2) > 1.0 from bempp.api.operators.potential import helmholtz as helmholtz_potential slp_pot = helmholtz_potential.single_layer(piecewise_const_space, points[:, idx], k) res = np.real(np.exp(1j * k * points[0, idx]) - slp_pot.evaluate(neumann_fun)) u_evaluated[idx] = res.flat # We now plot the slice of the domain solution. # In[11]: #get_ipython().run_line_magic('matplotlib', 'inline') u_evaluated = u_evaluated.reshape((Nx, Ny)) from matplotlib import pyplot as plt fig = plt.figure(figsize=(10, 8)) plt.imshow(np.real(u_evaluated.T), extent=[-3, 3, -3, 3]) plt.xlabel('x')
# Then we create a single layer potential operator and use it to evaluate the solution at the evaluation points. # In[11]: x, y, z =points idx = np.sqrt(x**2 + y**2) > 1.0 # The variable idx allows to compute only points located outside the unit circle of the plane. We use a single layer potential operator to evaluate the solution at the observation points. # In[12]: from bempp.api.operators.potential import helmholtz as helmholtz_potential slp_pot=helmholtz_potential.single_layer(piecewise_const_space,points[:,idx],k) res = np.real(np.exp(1j *k * points[0,idx]) - slp_pot.evaluate(neumann_fun)) u_evaluated[idx] = res.flat # We can now easily plot a slice of the domain solution. # In[13]: u_evaluated=u_evaluated.reshape((Nx, Ny)) print(' -> bempp computations done.') # get_ipython().magic('matplotlib inline') # Plot the image try: