def __call__(self, discr):
from hedge.discretization import ones_on_volume
mesh_volume = discr.integral(ones_on_volume(discr))
dx = (mesh_volume / len(discr)/ self.overresolve)**(1/discr.dimensions)
mesh = discr.mesh
bbox_min, bbox_max = mesh.bounding_box()
bbox_min -= self.mesh_margin
bbox_max += self.mesh_margin
bbox_size = bbox_max-bbox_min
dims = numpy.asarray(bbox_size/dx, dtype=numpy.int32)
stepwidths = bbox_size/dims
yield stepwidths, bbox_min, dims
def __call__(self, discr):
from hedge.discretization import ones_on_volume
mesh_volume = discr.integral(ones_on_volume(discr))
dx = (mesh_volume / len(discr) / self.overresolve)**(1 /
discr.dimensions)
mesh = discr.mesh
bbox_min, bbox_max = mesh.bounding_box()
bbox_min -= self.mesh_margin
bbox_max += self.mesh_margin
bbox_size = bbox_max - bbox_min
dims = numpy.asarray(bbox_size / dx, dtype=numpy.int32)
stepwidths = bbox_size / dims
yield stepwidths, bbox_min, dims
def test_quadrature_tri_mass_mat_monomial():
"""Check that quadrature integration on triangles is exact as designed."""
from hedge.mesh.generator import make_square_mesh
mesh = make_square_mesh(a=-1, b=1, max_area=4 * 1 / 8 + 0.001)
order = 4
discr = discr_class(
mesh, order=order, debug=discr_class.noninteractive_debug_flags(), quad_min_degrees={"quad": 3 * order}
)
m, n = 2, 1
f = Monomial((m, n))
f_vec = discr.interpolate_volume_function(lambda x, el: f(x))
from hedge.discretization import ones_on_volume
ones = ones_on_volume(discr)
if False:
from hedge.visualization import SiloVisualizer
vis = SiloVisualizer(discr)
visf = vis.make_file("test")
vis.add_data(visf, [("f", f_vec * f_vec)])
visf.close()
from hedge.optemplate import MassOperator, Field, QuadratureGridUpsampler
f_fld = Field("f")
mass_op = discr.compile(MassOperator()(f_fld * f_fld))
from hedge.optemplate.primitives import make_common_subexpression as cse
f_upsamp = cse(QuadratureGridUpsampler("quad")(f_fld))
quad_mass_op = discr.compile(MassOperator()(f_upsamp * f_upsamp))
num_integral_1 = numpy.dot(ones, mass_op(f=f_vec))
num_integral_2 = numpy.dot(ones, quad_mass_op(f=f_vec))
true_integral = 4 / ((2 * m + 1) * (2 * n + 1))
err_1 = abs(num_integral_1 - true_integral)
err_2 = abs(num_integral_2 - true_integral)
print num_integral_1, num_integral_2, true_integral
print err_1, err_2
assert err_1 > 1e-8
assert err_2 < 1e-14
def test_quadrature_tri_mass_mat_monomial():
"""Check that quadrature integration on triangles is exact as designed."""
from hedge.mesh.generator import make_square_mesh
mesh = make_square_mesh(a=-1, b=1, max_area=4 * 1 / 8 + 0.001)
order = 4
discr = discr_class(mesh,
order=order,
debug=discr_class.noninteractive_debug_flags(),
quad_min_degrees={"quad": 3 * order})
m, n = 2, 1
f = Monomial((m, n))
f_vec = discr.interpolate_volume_function(lambda x, el: f(x))
from hedge.discretization import ones_on_volume
ones = ones_on_volume(discr)
if False:
from hedge.visualization import SiloVisualizer
vis = SiloVisualizer(discr)
visf = vis.make_file("test")
vis.add_data(visf, [("f", f_vec * f_vec)])
visf.close()
from hedge.optemplate import (MassOperator, Field, QuadratureGridUpsampler)
f_fld = Field("f")
mass_op = discr.compile(MassOperator()(f_fld * f_fld))
from hedge.optemplate.primitives import make_common_subexpression as cse
f_upsamp = cse(QuadratureGridUpsampler("quad")(f_fld))
quad_mass_op = discr.compile(MassOperator()(f_upsamp * f_upsamp))
num_integral_1 = numpy.dot(ones, mass_op(f=f_vec))
num_integral_2 = numpy.dot(ones, quad_mass_op(f=f_vec))
true_integral = 4 / ((2 * m + 1) * (2 * n + 1))
err_1 = abs(num_integral_1 - true_integral)
err_2 = abs(num_integral_2 - true_integral)
print num_integral_1, num_integral_2, true_integral
print err_1, err_2
assert err_1 > 1e-8
assert err_2 < 1e-14
def __call__(self, discr):
mesh = discr.mesh
bbox_min, bbox_max = mesh.bounding_box()
d = len(bbox_min)
core_axis = self.core_axis
if core_axis is None:
core_axis = d-1
# calculate outer bbox, as above
from hedge.discretization import ones_on_volume
mesh_volume = discr.integral(ones_on_volume(discr))
dx = (mesh_volume / len(discr)/ self.overresolve)**(1/discr.dimensions)
bbox_min -= self.mesh_margin
bbox_max += self.mesh_margin
bbox_size = bbox_max-bbox_min
dims = numpy.asarray(bbox_size/dx, dtype=numpy.int32)
stepwidths = bbox_size/dims
# calculate inner bbox
core_margin_dims = (dims*(1-self.core_fraction)/2).astype(numpy.int32)
core_margin_dims[core_axis] = 0
core_dx = dx/self.core_factor
core_min = bbox_min + stepwidths*core_margin_dims
core_max = bbox_max - stepwidths*core_margin_dims
core_size = core_max-core_min
core_dims = numpy.asarray(core_size/core_dx, dtype=numpy.int32)
core_stepwidths = core_size/core_dims
# yield the core
yield core_stepwidths, core_min, core_dims
# yield the surrounding bricks
from hedge.tools import unit_vector
axis_vec = unit_vector(d, core_axis, dtype=numpy.int32)
if d == 2:
margin_dims = core_margin_dims + dims*axis_vec
yield stepwidths, bbox_min, margin_dims
yield -stepwidths, bbox_max, margin_dims
elif d == 3:
other_axes = set(range(d)) - set([core_axis])
x, y = other_axes
# ^ y
# |
# +----+----------+-----+
# | | 2 | |
# | +----------+ |
# | 1 | core | 1 |
# | +----------+ |
# | | 2 | |
# +----+----------+-----+--> x
#
x_vec = unit_vector(d, x, dtype=numpy.int32)
dims1 = dims.copy()
dims1[x] = core_margin_dims[x]
dims2 = dims.copy()
dims2[x] = dims[x]-2*core_margin_dims[x]
dims2[y] = core_margin_dims[y]
yield stepwidths, bbox_min, dims1
yield -stepwidths, bbox_max, dims1
x_offset_2 = x_vec*core_margin_dims[x]*stepwidths[x]
yield stepwidths, bbox_min+x_offset_2, dims2
yield -stepwidths, bbox_max-x_offset_2, dims2
else:
raise ValueError, "invalid dimensionality"
def test_interior_fluxes_tet():
"""Check tetrahedron surface integrals computed using interior fluxes
against their known values.
"""
import meshpy.tet as tet
from math import pi, sin, cos
mesh_info = tet.MeshInfo()
# construct a two-box extrusion of this base
base = [(-pi, -pi, 0), (pi, -pi, 0), (pi, pi, 0), (-pi, pi, 0)]
# first, the nodes
mesh_info.set_points(base + [(x, y, z + pi)
for x, y, z in base] + [(x, y, z + pi + 1)
for x, y, z in base])
# next, the facets
# vertex indices for a box missing the -z face
box_without_minus_z = [
[4, 5, 6, 7],
[0, 4, 5, 1],
[1, 5, 6, 2],
[2, 6, 7, 3],
[3, 7, 4, 0],
]
def add_to_all_vertex_indices(facets, increment):
return [[pt + increment for pt in facet] for facet in facets]
mesh_info.set_facets(
[[0, 1, 2, 3]] # base
+ box_without_minus_z # first box
+ add_to_all_vertex_indices(box_without_minus_z, 4) # second box
)
# set the volume properties -- this is where the tet size constraints are
mesh_info.regions.resize(2)
mesh_info.regions[0] = [
0,
0,
pi / 2, # point in volume -> first box
0, # region tag (user-defined number)
0.5, # max tet volume in region
]
mesh_info.regions[1] = [
0,
0,
pi + 0.5, # point in volume -> second box
1, # region tag (user-defined number, arbitrary)
0.1, # max tet volume in region
]
generated_mesh = tet.build(mesh_info,
attributes=True,
volume_constraints=True)
from hedge.mesh import make_conformal_mesh
mesh = make_conformal_mesh(generated_mesh.points, generated_mesh.elements)
from hedge.discretization.local import TetrahedronDiscretization
from hedge.discretization import ones_on_volume
discr = discr_class(mesh,
TetrahedronDiscretization(4),
debug=discr_class.noninteractive_debug_flags())
def f_u(x, el):
if generated_mesh.element_attributes[el.id] == 1:
return cos(x[0] - x[1] + x[2])
else:
return 0
def f_l(x, el):
if generated_mesh.element_attributes[el.id] == 0:
return sin(x[0] - x[1] + x[2])
else:
return 0
u_l = discr.interpolate_volume_function(f_l)
u_u = discr.interpolate_volume_function(f_u)
u = u_l + u_u
# visualize the produced field
#from hedge.visualization import SiloVisualizer
#vis = SiloVisualizer(discr)
#visf = vis.make_file("sandwich")
#vis.add_data(visf,
#[("u_l", u_l), ("u_u", u_u)],
#expressions=[("u", "u_l+u_u")])
# make sure the surface integral of the difference
# between top and bottom is zero
from hedge.flux import make_normal, FluxScalarPlaceholder
from hedge.optemplate import Field, get_flux_operator
fluxu = FluxScalarPlaceholder()
res = discr.compile(
get_flux_operator(
(fluxu.int - fluxu.ext) * make_normal(discr.dimensions)[1]) *
Field("u"))(u=u)
ones = ones_on_volume(discr)
assert abs(numpy.dot(res, ones)) < 5e-14
def test_interior_fluxes_tri():
"""Check triangle surface integrals computed using interior fluxes
against their known values.
"""
from math import pi, sin, cos
def round_trip_connect(start, end):
for i in range(start, end):
yield i, i + 1
yield end, start
a = -pi
b = pi
points = [(a, 0), (b, 0), (a, -1), (b, -1), (a, 1), (b, 1)]
import meshpy.triangle as triangle
mesh_info = triangle.MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets([(0, 1), (1, 3), (3, 2), (2, 0), (0, 4), (4, 5),
(1, 5)])
mesh_info.regions.resize(2)
mesh_info.regions[0] = [
0,
-0.5, # coordinate
1, # lower element tag
0.1, # max area
]
mesh_info.regions[1] = [
0,
0.5, # coordinate
2, # upper element tag
0.01, # max area
]
generated_mesh = triangle.build(mesh_info,
attributes=True,
volume_constraints=True)
#triangle.write_gnuplot_mesh("mesh.dat", generated_mesh)
def element_tagger(el):
if generated_mesh.element_attributes[el.id] == 1:
return ["upper"]
else:
return ["lower"]
from hedge.mesh import make_conformal_mesh
mesh = make_conformal_mesh(generated_mesh.points, generated_mesh.elements)
from hedge.discretization.local import TriangleDiscretization
from hedge.discretization import ones_on_volume
discr = discr_class(mesh,
TriangleDiscretization(4),
debug=discr_class.noninteractive_debug_flags())
def f_u(x, el):
if generated_mesh.element_attributes[el.id] == 1:
return cos(x[0] - x[1])
else:
return 0
def f_l(x, el):
if generated_mesh.element_attributes[el.id] == 0:
return sin(x[0] - x[1])
else:
return 0
# u_l = discr.interpolate_volume_function(f_l)
u_u = discr.interpolate_volume_function(f_u)
u = u_u + u_u
#discr.visualize_vtk("dual.vtk", [("u", u)])
from hedge.flux import make_normal, FluxScalarPlaceholder
from hedge.optemplate import Field, get_flux_operator
fluxu = FluxScalarPlaceholder()
res = discr.compile(
get_flux_operator(
(fluxu.int - fluxu.ext) * make_normal(discr.dimensions)[1]) *
Field("u"))(u=u)
ones = ones_on_volume(discr)
err = abs(numpy.dot(res, ones))
#print err
assert err < 5e-14
def test_2d_gauss_theorem():
"""Verify Gauss's theorem explicitly on a mesh"""
from hedge.mesh.generator import make_disk_mesh
from math import sin, cos
from numpy import dot
mesh = make_disk_mesh()
order = 2
discr = discr_class(mesh,
order=order,
debug=discr_class.noninteractive_debug_flags())
ref_discr = discr_class(mesh, order=order)
from hedge.flux import make_normal, FluxScalarPlaceholder
normal = make_normal(discr.dimensions)
flux_f_ph = FluxScalarPlaceholder(0)
one_sided_x = flux_f_ph.int * normal[0]
one_sided_y = flux_f_ph.int * normal[1]
def f1(x, el):
return sin(3 * x[0]) + cos(3 * x[1])
def f2(x, el):
return sin(2 * x[0]) + cos(x[1])
from hedge.discretization import ones_on_volume
ones = ones_on_volume(discr)
f1_v = discr.interpolate_volume_function(f1)
f2_v = discr.interpolate_volume_function(f2)
from hedge.optemplate import BoundaryPair, Field, make_nabla, \
get_flux_operator
nabla = make_nabla(discr.dimensions)
divergence = nabla[0].apply(discr, f1_v) + nabla[1].apply(discr, f2_v)
int_div = discr.integral(divergence)
flux_optp = (
get_flux_operator(one_sided_x)(BoundaryPair(Field("f1"),
Field("fz"))) +
get_flux_operator(one_sided_y)(BoundaryPair(Field("f2"), Field("fz"))))
from hedge.mesh import TAG_ALL
bdry_val = discr.compile(flux_optp)(f1=f1_v,
f2=f2_v,
fz=discr.boundary_zeros(TAG_ALL))
ref_bdry_val = ref_discr.compile(flux_optp)(
f1=f1_v, f2=f2_v, fz=discr.boundary_zeros(TAG_ALL))
boundary_int = dot(bdry_val, ones)
if False:
from hedge.visualization import SiloVisualizer
vis = SiloVisualizer(discr)
visf = vis.make_file("test")
from hedge.tools import make_obj_array
from hedge.mesh import TAG_ALL
vis.add_data(visf, [
("bdry", bdry_val),
("ref_bdry", ref_bdry_val),
("div", divergence),
("f", make_obj_array([f1_v, f2_v])),
("n",
discr.volumize_boundary_field(discr.boundary_normals(TAG_ALL),
TAG_ALL)),
],
expressions=[("bdiff", "bdry-ref_bdry")])
#print abs(boundary_int-int_div)
assert abs(boundary_int - int_div) < 5e-15
def __call__(self, discr):
mesh = discr.mesh
bbox_min, bbox_max = mesh.bounding_box()
d = len(bbox_min)
core_axis = self.core_axis
if core_axis is None:
core_axis = d - 1
# calculate outer bbox, as above
from hedge.discretization import ones_on_volume
mesh_volume = discr.integral(ones_on_volume(discr))
dx = (mesh_volume / len(discr) / self.overresolve)**(1 /
discr.dimensions)
bbox_min -= self.mesh_margin
bbox_max += self.mesh_margin
bbox_size = bbox_max - bbox_min
dims = numpy.asarray(bbox_size / dx, dtype=numpy.int32)
stepwidths = bbox_size / dims
# calculate inner bbox
core_margin_dims = (dims * (1 - self.core_fraction) / 2).astype(
numpy.int32)
core_margin_dims[core_axis] = 0
core_dx = dx / self.core_factor
core_min = bbox_min + stepwidths * core_margin_dims
core_max = bbox_max - stepwidths * core_margin_dims
core_size = core_max - core_min
core_dims = numpy.asarray(core_size / core_dx, dtype=numpy.int32)
core_stepwidths = core_size / core_dims
# yield the core
yield core_stepwidths, core_min, core_dims
# yield the surrounding bricks
from hedge.tools import unit_vector
axis_vec = unit_vector(d, core_axis, dtype=numpy.int32)
if d == 2:
margin_dims = core_margin_dims + dims * axis_vec
yield stepwidths, bbox_min, margin_dims
yield -stepwidths, bbox_max, margin_dims
elif d == 3:
other_axes = set(range(d)) - set([core_axis])
x, y = other_axes
# ^ y
# |
# +----+----------+-----+
# | | 2 | |
# | +----------+ |
# | 1 | core | 1 |
# | +----------+ |
# | | 2 | |
# +----+----------+-----+--> x
#
x_vec = unit_vector(d, x, dtype=numpy.int32)
dims1 = dims.copy()
dims1[x] = core_margin_dims[x]
dims2 = dims.copy()
dims2[x] = dims[x] - 2 * core_margin_dims[x]
dims2[y] = core_margin_dims[y]
yield stepwidths, bbox_min, dims1
yield -stepwidths, bbox_max, dims1
x_offset_2 = x_vec * core_margin_dims[x] * stepwidths[x]
yield stepwidths, bbox_min + x_offset_2, dims2
yield -stepwidths, bbox_max - x_offset_2, dims2
else:
raise ValueError, "invalid dimensionality"
def test_interior_fluxes_tet():
"""Check tetrahedron surface integrals computed using interior fluxes
against their known values.
"""
import meshpy.tet as tet
from math import pi, sin, cos
mesh_info = tet.MeshInfo()
# construct a two-box extrusion of this base
base = [(-pi, -pi, 0), (pi, -pi, 0), (pi, pi, 0), (-pi, pi, 0)]
# first, the nodes
mesh_info.set_points(base + [(x, y, z + pi) for x, y, z in base] + [(x, y, z + pi + 1) for x, y, z in base])
# next, the facets
# vertex indices for a box missing the -z face
box_without_minus_z = [[4, 5, 6, 7], [0, 4, 5, 1], [1, 5, 6, 2], [2, 6, 7, 3], [3, 7, 4, 0]]
def add_to_all_vertex_indices(facets, increment):
return [[pt + increment for pt in facet] for facet in facets]
mesh_info.set_facets(
[[0, 1, 2, 3]] # base
+ box_without_minus_z # first box
+ add_to_all_vertex_indices(box_without_minus_z, 4) # second box
)
# set the volume properties -- this is where the tet size constraints are
mesh_info.regions.resize(2)
mesh_info.regions[0] = [
0,
0,
pi / 2, # point in volume -> first box
0, # region tag (user-defined number)
0.5, # max tet volume in region
]
mesh_info.regions[1] = [
0,
0,
pi + 0.5, # point in volume -> second box
1, # region tag (user-defined number, arbitrary)
0.1, # max tet volume in region
]
generated_mesh = tet.build(mesh_info, attributes=True, volume_constraints=True)
from hedge.mesh import make_conformal_mesh
mesh = make_conformal_mesh(generated_mesh.points, generated_mesh.elements)
from hedge.discretization.local import TetrahedronDiscretization
from hedge.discretization import ones_on_volume
discr = discr_class(mesh, TetrahedronDiscretization(4), debug=discr_class.noninteractive_debug_flags())
def f_u(x, el):
if generated_mesh.element_attributes[el.id] == 1:
return cos(x[0] - x[1] + x[2])
else:
return 0
def f_l(x, el):
if generated_mesh.element_attributes[el.id] == 0:
return sin(x[0] - x[1] + x[2])
else:
return 0
u_l = discr.interpolate_volume_function(f_l)
u_u = discr.interpolate_volume_function(f_u)
u = u_l + u_u
# visualize the produced field
# from hedge.visualization import SiloVisualizer
# vis = SiloVisualizer(discr)
# visf = vis.make_file("sandwich")
# vis.add_data(visf,
# [("u_l", u_l), ("u_u", u_u)],
# expressions=[("u", "u_l+u_u")])
# make sure the surface integral of the difference
# between top and bottom is zero
from hedge.flux import make_normal, FluxScalarPlaceholder
from hedge.optemplate import Field, get_flux_operator
fluxu = FluxScalarPlaceholder()
res = discr.compile(get_flux_operator((fluxu.int - fluxu.ext) * make_normal(discr.dimensions)[1]) * Field("u"))(u=u)
from hedge.discretization import ones_on_volume
ones = ones_on_volume(discr)
assert abs(numpy.dot(res, ones)) < 5e-14
def test_interior_fluxes_tri():
"""Check triangle surface integrals computed using interior fluxes
against their known values.
"""
from math import pi, sin, cos
def round_trip_connect(start, end):
for i in range(start, end):
yield i, i + 1
yield end, start
a = -pi
b = pi
points = [(a, 0), (b, 0), (a, -1), (b, -1), (a, 1), (b, 1)]
import meshpy.triangle as triangle
mesh_info = triangle.MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets([(0, 1), (1, 3), (3, 2), (2, 0), (0, 4), (4, 5), (1, 5)])
mesh_info.regions.resize(2)
mesh_info.regions[0] = [0, -0.5, 1, 0.1] # coordinate # lower element tag # max area
mesh_info.regions[1] = [0, 0.5, 2, 0.01] # coordinate # upper element tag # max area
generated_mesh = triangle.build(mesh_info, attributes=True, volume_constraints=True)
# triangle.write_gnuplot_mesh("mesh.dat", generated_mesh)
def element_tagger(el):
if generated_mesh.element_attributes[el.id] == 1:
return ["upper"]
else:
return ["lower"]
from hedge.mesh import make_conformal_mesh
mesh = make_conformal_mesh(generated_mesh.points, generated_mesh.elements)
from hedge.discretization.local import TriangleDiscretization
from hedge.discretization import ones_on_volume
discr = discr_class(mesh, TriangleDiscretization(4), debug=discr_class.noninteractive_debug_flags())
def f_u(x, el):
if generated_mesh.element_attributes[el.id] == 1:
return cos(x[0] - x[1])
else:
return 0
def f_l(x, el):
if generated_mesh.element_attributes[el.id] == 0:
return sin(x[0] - x[1])
else:
return 0
u_l = discr.interpolate_volume_function(f_l)
u_u = discr.interpolate_volume_function(f_u)
u = u_u + u_u
# discr.visualize_vtk("dual.vtk", [("u", u)])
from hedge.flux import make_normal, FluxScalarPlaceholder
from hedge.optemplate import Field, get_flux_operator
fluxu = FluxScalarPlaceholder()
res = discr.compile(get_flux_operator((fluxu.int - fluxu.ext) * make_normal(discr.dimensions)[1]) * Field("u"))(u=u)
from hedge.discretization import ones_on_volume
ones = ones_on_volume(discr)
err = abs(numpy.dot(res, ones))
# print err
assert err < 5e-14
def test_2d_gauss_theorem():
"""Verify Gauss's theorem explicitly on a mesh"""
from hedge.mesh.generator import make_disk_mesh
from math import sin, cos, sqrt, exp, pi
from numpy import dot
mesh = make_disk_mesh()
order = 2
discr = discr_class(mesh, order=order, debug=discr_class.noninteractive_debug_flags())
ref_discr = discr_class(mesh, order=order)
from hedge.flux import make_normal, FluxScalarPlaceholder
normal = make_normal(discr.dimensions)
flux_f_ph = FluxScalarPlaceholder(0)
one_sided_x = flux_f_ph.int * normal[0]
one_sided_y = flux_f_ph.int * normal[1]
def f1(x, el):
return sin(3 * x[0]) + cos(3 * x[1])
def f2(x, el):
return sin(2 * x[0]) + cos(x[1])
from hedge.discretization import ones_on_volume
ones = ones_on_volume(discr)
f1_v = discr.interpolate_volume_function(f1)
f2_v = discr.interpolate_volume_function(f2)
from hedge.optemplate import BoundaryPair, Field, make_nabla, get_flux_operator
nabla = make_nabla(discr.dimensions)
diff_optp = nabla[0] * Field("f1") + nabla[1] * Field("f2")
divergence = nabla[0].apply(discr, f1_v) + nabla[1].apply(discr, f2_v)
int_div = discr.integral(divergence)
flux_optp = get_flux_operator(one_sided_x)(BoundaryPair(Field("f1"), Field("fz"))) + get_flux_operator(one_sided_y)(
BoundaryPair(Field("f2"), Field("fz"))
)
from hedge.mesh import TAG_ALL
bdry_val = discr.compile(flux_optp)(f1=f1_v, f2=f2_v, fz=discr.boundary_zeros(TAG_ALL))
ref_bdry_val = ref_discr.compile(flux_optp)(f1=f1_v, f2=f2_v, fz=discr.boundary_zeros(TAG_ALL))
boundary_int = dot(bdry_val, ones)
if False:
from hedge.visualization import SiloVisualizer
vis = SiloVisualizer(discr)
visf = vis.make_file("test")
from hedge.tools import make_obj_array
from hedge.mesh import TAG_ALL
vis.add_data(
visf,
[
("bdry", bdry_val),
("ref_bdry", ref_bdry_val),
("div", divergence),
("f", make_obj_array([f1_v, f2_v])),
("n", discr.volumize_boundary_field(discr.boundary_normals(TAG_ALL), TAG_ALL)),
],
expressions=[("bdiff", "bdry-ref_bdry")],
)
# print abs(boundary_int-int_div)
assert abs(boundary_int - int_div) < 5e-15
