def test_tri_map():
"""Verify that the mapping and node-building operations maintain triangle vertices"""
from hedge.discretization.local import TriangleDiscretization
n = 8
tri = TriangleDiscretization(n)
node_dict = dict((ituple, idx) for idx, ituple in enumerate(tri.node_tuples()))
corner_indices = [node_dict[0,0], node_dict[n,0], node_dict[0,n]]
unodes = tri.unit_nodes()
corners = [unodes[i] for i in corner_indices]
for i in range(10):
vertices = [numpy.random.randn(2) for vi in range(3)]
map = tri.geometry.get_map_unit_to_global(vertices)
global_corners = [map(pt) for pt in corners]
for gc, v in zip(global_corners, vertices):
assert la.norm(gc-v) < 1e-12
def test_tri_map():
"""Verify that the mapping and node-building operations maintain triangle vertices"""
from hedge.discretization.local import TriangleDiscretization
n = 8
tri = TriangleDiscretization(n)
node_dict = dict((ituple, idx) for idx, ituple in enumerate(tri.node_tuples()))
corner_indices = [node_dict[0,0], node_dict[n,0], node_dict[0,n]]
unodes = tri.unit_nodes()
corners = [unodes[i] for i in corner_indices]
for i in range(10):
vertices = [numpy.random.randn(2) for vi in range(3)]
map = tri.geometry.get_map_unit_to_global(vertices)
global_corners = [map(pt) for pt in corners]
for gc, v in zip(global_corners, vertices):
assert la.norm(gc-v) < 1e-12
def test_tri_nodes_against_known_values():
"""Check triangle nodes against a previous implementation"""
from hedge.discretization.local import TriangleDiscretization
triorder = 8
tri = TriangleDiscretization(triorder)
def tri_equilateral_nodes_reference(self):
# This is the old, more explicit, less general way of computing
# the triangle nodes. Below, we compare its results with that of the
# new routine.
alpha_opt = [0.0000, 0.0000, 1.4152, 0.1001, 0.2751, 0.9800, 1.0999,
1.2832, 1.3648, 1.4773, 1.4959, 1.5743, 1.5770, 1.6223, 1.6258]
try:
alpha = alpha_opt[self.order-1]
except IndexError:
alpha = 5/3
from hedge.discretization.local import WarpFactorCalculator
from math import sin, cos, pi
warp = WarpFactorCalculator(self.order)
edge1dir = numpy.array([1,0])
edge2dir = numpy.array([cos(2*pi/3), sin(2*pi/3)])
edge3dir = numpy.array([cos(4*pi/3), sin(4*pi/3)])
for bary in self.equidistant_barycentric_nodes():
lambda1, lambda2, lambda3 = bary
# find equidistant (x,y) coordinates in equilateral triangle
point = self.barycentric_to_equilateral(bary)
# compute blend factors
blend1 = 4*lambda1*lambda2 # nonzero on AB
blend2 = 4*lambda3*lambda2 # nonzero on BC
blend3 = 4*lambda3*lambda1 # nonzero on AC
# calculate amount of warp for each node, for each edge
warp1 = blend1*warp(lambda2 - lambda1)*(1 + (alpha*lambda3)**2)
warp2 = blend2*warp(lambda3 - lambda2)*(1 + (alpha*lambda1)**2)
warp3 = blend3*warp(lambda1 - lambda3)*(1 + (alpha*lambda2)**2)
# return warped point
yield point + warp1*edge1dir + warp2*edge2dir + warp3*edge3dir
if False:
outf = open("trinodes1.dat", "w")
for ux in tri.equilateral_nodes():
outf.write("%g\t%g\n" % tuple(ux))
outf = open("trinodes2.dat", "w")
for ux in tri_equilateral_nodes_reference(tri):
outf.write("%g\t%g\n" % tuple(ux))
for n1, n2 in zip(tri.equilateral_nodes(),
tri_equilateral_nodes_reference(tri)):
assert la.norm(n1-n2) < 3e-15
def node_indices_2(order):
for n in range(0, order+1):
for m in range(0, order+1-n):
yield m,n
assert set(tri.node_tuples()) == set(node_indices_2(triorder))
def test_tri_nodes_against_known_values():
"""Check triangle nodes against a previous implementation"""
from hedge.discretization.local import TriangleDiscretization
triorder = 8
tri = TriangleDiscretization(triorder)
def tri_equilateral_nodes_reference(self):
# This is the old, more explicit, less general way of computing
# the triangle nodes. Below, we compare its results with that of the
# new routine.
alpha_opt = [0.0000, 0.0000, 1.4152, 0.1001, 0.2751, 0.9800, 1.0999,
1.2832, 1.3648, 1.4773, 1.4959, 1.5743, 1.5770, 1.6223, 1.6258]
try:
alpha = alpha_opt[self.order-1]
except IndexError:
alpha = 5/3
from hedge.discretization.local import WarpFactorCalculator
from math import sin, cos, pi
warp = WarpFactorCalculator(self.order)
edge1dir = numpy.array([1,0])
edge2dir = numpy.array([cos(2*pi/3), sin(2*pi/3)])
edge3dir = numpy.array([cos(4*pi/3), sin(4*pi/3)])
for bary in self.equidistant_barycentric_nodes():
lambda1, lambda2, lambda3 = bary
# find equidistant (x,y) coordinates in equilateral triangle
point = self.barycentric_to_equilateral(bary)
# compute blend factors
blend1 = 4*lambda1*lambda2 # nonzero on AB
blend2 = 4*lambda3*lambda2 # nonzero on BC
blend3 = 4*lambda3*lambda1 # nonzero on AC
# calculate amount of warp for each node, for each edge
warp1 = blend1*warp(lambda2 - lambda1)*(1 + (alpha*lambda3)**2)
warp2 = blend2*warp(lambda3 - lambda2)*(1 + (alpha*lambda1)**2)
warp3 = blend3*warp(lambda1 - lambda3)*(1 + (alpha*lambda2)**2)
# return warped point
yield point + warp1*edge1dir + warp2*edge2dir + warp3*edge3dir
if False:
outf = open("trinodes1.dat", "w")
for ux in tri.equilateral_nodes():
outf.write("%g\t%g\n" % tuple(ux))
outf = open("trinodes2.dat", "w")
for ux in tri_equilateral_nodes_reference(tri):
outf.write("%g\t%g\n" % tuple(ux))
for n1, n2 in zip(tri.equilateral_nodes(),
tri_equilateral_nodes_reference(tri)):
assert la.norm(n1-n2) < 3e-15
def node_indices_2(order):
for n in range(0, order+1):
for m in range(0, order+1-n):
yield m,n
assert set(tri.node_tuples()) == set(node_indices_2(triorder))
