def coefficients_from_boxes(self,
discr,
inner_bbox,
outer_bbox=None,
magnitude=None,
tau_magnitude=None,
exponent=None,
dtype=None):
if outer_bbox is None:
outer_bbox = discr.mesh.bounding_box()
if exponent is None:
exponent = 2
if magnitude is None:
magnitude = 20
if tau_magnitude is None:
tau_magnitude = 0.4
# scale by free space conductivity
from math import sqrt
magnitude = magnitude * sqrt(self.epsilon / self.mu)
tau_magnitude = tau_magnitude * sqrt(self.epsilon / self.mu)
i_min, i_max = inner_bbox
o_min, o_max = outer_bbox
from grudge.tools import make_obj_array
nodes = discr.nodes
if dtype is not None:
nodes = nodes.astype(dtype)
sigma, sigma_prime, tau = list(
zip(*[
self._construct_scalar_coefficients(
discr, nodes[:, i], i_min[i], i_max[i], o_min[i], o_max[i],
exponent) for i in range(discr.dimensions)
]))
def conv(f):
return discr.convert_volume(f,
kind=discr.compute_kind,
dtype=discr.default_scalar_type)
return self.PMLCoefficients(
sigma=conv(magnitude * make_obj_array(sigma)),
sigma_prime=conv(magnitude * make_obj_array(sigma_prime)),
tau=conv(tau_magnitude * make_obj_array(tau)))
def volume_interpolant(self, t, discr):
from grudge.tools import make_obj_array
result = discr.volume_zeros(kind="numpy", dtype=np.float64)
omega = 6*c
if omega*t > 2*pi:
return make_obj_array([result, result, result])
x = make_obj_array(discr.nodes.T)
r = np.sqrt(np.dot(x, x))
idx = r<0.3
result[idx] = (1+np.cos(pi*r/0.3))[idx] \
*np.sin(omega*t)**3
result = discr.convert_volume(result, kind=discr.compute_kind,
dtype=discr.default_scalar_type)
return make_obj_array([-result, result, result])
def initial_val(discr):
# the initial solution for the TE_10-like mode
def initial_Hz(x, el):
from math import cos, sin
if el in material_elements["vacuum"]:
return h * cos(h * x[0])
else:
return -l * sin(h * d) / sin(l * (a - d)) * cos(l * (a - x[0]))
from grudge.tools import make_obj_array
result_zero = discr.volume_zeros(kind="numpy", dtype=numpy.float64)
H_z = make_tdep_given(initial_Hz).volume_interpolant(0, discr)
return make_obj_array([result_zero, result_zero, H_z])
def __call__(self, t, x_vec):
ones = numpy.ones_like(x_vec[0])
rho_field = ones*self.rho
if self.gaussian_pulse_at is not None:
rel_to_pulse = [x_vec[i] - self.gaussian_pulse_at[i]
for i in range(len(x_vec))]
rho_field += self.pulse_magnitude * self.rho * numpy.exp(
- sum(rtp_i**2 for rtp_i in rel_to_pulse)/2)
direction = self.direction_vector(x_vec.shape[0])
from grudge.tools import make_obj_array
u_field = make_obj_array([ones*self.velocity*dir_i
for dir_i in direction])
from grudge.tools import join_fields
return join_fields(rho_field, self.e*ones, self.rho*u_field)
def volume_interpolant(self, t, discr):
from grudge.tools import make_obj_array
return make_obj_array([
self.vol_0, self.vol_0,
sph_dipole.source_modulation(t) * self.num_sf
])
