def test_Rectangle_XY_system(self):
ranks = getMPISizeWorld()
for expanded in (True, False):
for order in range(2, 11):
dom = Rectangle(order, 3, 3 * ranks, l0=6, l1=6, d1=ranks)
Y = Data(1, (2, ), Function(dom), expanded)
X = Data(0, (2, 2), Function(dom), expanded)
X[0, 0] = dom.getX()[0]
X[1, 1] = dom.getX()[1]
f = Data(0, (2, ), Solution(dom), expanded)
dom.addToRHS(f, [("Y", Y)],
dom.createAssembler("DefaultAssembler", []))
dom.addToRHS(f, [("X", X)],
dom.createAssembler("DefaultAssembler", []))
#nuke the boundary back to zero since it's not dealt with here
f *= whereNegative(dom.getX()[0] -
6) * whereNegative(dom.getX()[1] - 6)
res = Lsup(f)
self.assertLess(
res, self.TOLERANCE,
("assembly for {0}expanded order %d failed with %e >= %e" %
(order, res,
self.TOLERANCE)).format("" if expanded else "un-"))
def test_Rectangle_MPI_construction_multi_dimensional(self):
ranks = getMPISizeWorld()
half = 2 #change if ranks != 4 (sqrt(ranks))
for order in range(2, 11):
dom = Rectangle(order, ranks, ranks, l0=half, l1=half,
d0=half, d1=half)
self.assertEqual(Lsup(dom.getX()[0]), half,
"invalid getX() for multidimensional splits in order %d"%order)
self.assertEqual(Lsup(dom.getX()[1]), half,
"invalid getX() for multidimensional splits in order %d"%order)
xfilt = whereZero(dom.getX()[0] - 1) + whereZero(dom.getX()[1] - 1)
for i in range(2,half):
xfilt += whereZero(dom.getX()[0] - i)
xfilt += whereZero(dom.getX()[1] - i)
xfilt = whereNonZero(xfilt)
if getMPIRankWorld() in [1,2]: #change if ranks != 4
xfilt *= -1
X = interpolate(xfilt, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res)
self.assertEqual(val, 0,
"summation failure for mixed-splits in order %d"%order)
X = interpolate(xfilt+2, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res-2)
self.assertEqual(val, 0,
"averaging failure for mixed-splits in order %d"%order)
def test_Rectangle_interpolation_continuous_noncontinuous_and_back(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Rectangle(order, 3, 3 * ranks, d1=ranks, l0=6, l1=6)
original = Data(5, Function(dom), True)
cont = interpolate(original, ContinuousFunction(dom))
func = interpolate(cont, Function(dom))
self.assertEqual(
Lsup(original - func), 0,
"interpolation of constant, order %d: original and final not equal, %e != 0"
% (order, Lsup(original - func)))
x = dom.getX()
original = x[0] + x[1] + 1
cont = interpolate(original, ContinuousFunction(dom))
func = interpolate(cont, Function(dom))
self.assertEqual(
Lsup(original - func), 0,
"interpolation of expanded, order %d: original and final not equal, %e != 0"
% (order, Lsup(original - func)))
original = whereZero(x[0] - 2) + whereZero(x[1] - 2)
cont = interpolate(original, ContinuousFunction(dom))
func = interpolate(cont, Function(dom))
self.assertEqual(
Lsup(original - func), 0,
"interpolation of point, order %d: original and final not equal, %e != 0"
% (order, Lsup(original - func)))
def test_Rectangle_ContinuousFunction_gradient(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Rectangle(order, 3, 3 * ranks, d1=ranks, l0=100, l1=100)
X = dom.getX()
u = X[0] + X[1] + 1
v = Lsup(grad(u) - 1)
self.assertLess(
v, 1e-10,
"order %d, %e >= 1e-10, %s" % (order, v, str(grad(u) - 1)))
for power in range(1, order + 1):
for power2 in range(1, order + 1):
a = X[0]**power * X[1]**power2
da = grad(a)
first = Lsup(da[0] - power*X[0]**(power-1) * X[1]**power2) \
/Lsup(power*X[0]**(power-1) * X[1]**power2)
second = Lsup(da[1] - power2*X[1]**(power2-1) * X[0]**power) \
/Lsup(power2*X[1]**(power2-1) * X[0]**power)
self.assertLess(
first, 1e-10, "order %d and degree %d,%d, %e >= 1e-9" %
(order, power, power2, first))
self.assertLess(
second, 1e-10,
"order %d and degree %d,%d, %e >= 1e-9" %
(order, power, power2, second))
def test_Rectangle_XY_single(self):
ranks = getMPISizeWorld()
for expanded in (True, False):
for order in range(2,11):
dom = Rectangle(order, 3, 3*ranks, d1=ranks, l0=6, l1=6)
Y = Data(2, Function(dom), expanded)
X = Data(0, (2,), Function(dom), expanded)
X[0] = dom.getX()[0]
X[1] = dom.getX()[1]
f = Data(0, Solution(dom), expanded)
dom.addToRHS(f, [("Y",Y)],
dom.createAssembler("DefaultAssembler", []))
dom.addToRHS(f, [("X", X)],
dom.createAssembler("DefaultAssembler", []))
#nuke the boundary back to zero since it's not dealt with here
for dim in range(2):
f *= whereNegative(dom.getX()[dim]-6)
res = Lsup(f)
self.assertLess(res, self.TOLERANCE,
("assembly for {0}expanded order %d failed with %e >= %e"%(order,
res, self.TOLERANCE)).format("" if expanded else "un-"))
def test_Rectangle_integration(self):
ranks = getMPISizeWorld()
for order in range(2,11):
size = 6
dom = Rectangle(order, 3, 3*ranks, d1=ranks, l0=size, l1=size)
X = dom.getX()
for k in range(1, order * 2):
for l in range(1, order * 2):
powered = X[0]**k * X[1]**l
integral = integrate(powered)
actual = size**(k+1) * size**(l+1) / ((k+1.)*(l+1.))
self.assertLess(abs(integral - actual)/actual, 1e-11,
"too much variance in integral result (order %d, degrees %d %d)"%(order, k, l))
def xtest_Rectangle_MPI_construction_multi_dimensional(self):
ranks = getMPISizeWorld()
half = 2 #change if ranks != 4 (sqrt(ranks))
for order in range(2, 11):
dom = Rectangle(order,
ranks,
ranks,
l0=half,
l1=half,
d0=half,
d1=half)
self.assertEqual(
Lsup(dom.getX()[0]), half,
"invalid getX() for multidimensional splits in order %d" %
order)
self.assertEqual(
Lsup(dom.getX()[1]), half,
"invalid getX() for multidimensional splits in order %d" %
order)
xfilt = whereZero(dom.getX()[0] - 1) + whereZero(dom.getX()[1] - 1)
for i in range(2, half):
xfilt += whereZero(dom.getX()[0] - i)
xfilt += whereZero(dom.getX()[1] - i)
xfilt = whereNonZero(xfilt)
if getMPIRankWorld() in [1, 2]: #change if ranks != 4
xfilt *= -1
X = interpolate(xfilt, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res)
self.assertEqual(
val, 0,
"summation failure for mixed-splits in order %d" % order)
X = interpolate(xfilt + 2, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res - 2)
self.assertEqual(
val, 0,
"averaging failure for mixed-splits in order %d" % order)
def xtest_Rectangle_MPI_construction_single_dimensional(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Rectangle(order, 2, 2 * ranks, l1=ranks, d1=ranks)
self.assertEqual(Lsup(dom.getX()[1] + dom.getX()[0]), ranks + 1,
"invalid getX() for y-splits order %d" % order)
filt = whereZero(dom.getX()[1] - 1)
for i in range(2, ranks):
filt += whereZero(dom.getX()[1] - i)
if getMPIRankWorld() % 2:
filt *= -1
d = Vector(0, Function(dom))
d[0] = 1 * filt
d[1] = 10 * filt
X = interpolate(d, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res)
self.assertEqual(
val, 0,
"summation stage failure for y-splits in order %d" % order)
dom = Rectangle(2, 2 * ranks, 2, l0=ranks, d0=ranks)
self.assertEqual(Lsup(dom.getX()[1] + dom.getX()[0]), ranks + 1,
"invalid getX() for x-splits order %d" % order)
filt = whereZero(dom.getX()[0] - 1)
for i in range(2, getMPISizeWorld()):
filt += whereZero(dom.getX()[0] - i)
if getMPIRankWorld() % 2:
filt *= -1
d = Vector(0, Function(dom))
d[0] = 1 * filt
d[1] = 10 * filt
X = interpolate(d, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res)
self.assertEqual(
val, 0,
"summation stage failure for x-splits in order %d" % order)
X = interpolate(d + 2, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res - 2)
self.assertEqual(
val, 0,
"averaging stage failure for x-splits in order %d" % order)
def xtest_Rectangle_integration(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
size = 6
dom = Rectangle(order, 3, 3 * ranks, d1=ranks, l0=size, l1=size)
X = dom.getX()
for k in range(1, order * 2):
for l in range(1, order * 2):
powered = X[0]**k * X[1]**l
integral = integrate(powered)
actual = size**(k + 1) * size**(l + 1) / ((k + 1.) *
(l + 1.))
self.assertLess(
abs(integral - actual) / actual, 1e-11,
"too much variance in integral result (order %d, degrees %d %d)"
% (order, k, l))
def test_Rectangle_ReducedFunction(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Rectangle(order, 3, 3*ranks, l0=3, l1=3*ranks, d1=ranks)
X = dom.getX()
redData = interpolate(X, ReducedFunction(dom))
data = [(interpolate(redData, ReducedFunction(dom)), "ReducedFunction"),
(interpolate(redData, Function(dom)), "Function"),
(interpolate(redData, ContinuousFunction(dom)), "ContinuousFunction")]
for d, fs in data:
self.assertLess(inf(d-[0.5]*2), self.TOLERANCE,
"reduced->%s failure with order %d: %e != 0"%(fs, order, inf(d-[0.5]*2)))
self.assertLess(sup(d[0]+0.5) - 3, self.TOLERANCE,
"reduced->%s failure with order %d: %e != 3"%(fs, order, sup(d[0]+0.5)))
self.assertLess(sup(d[1]+0.5) - 3*ranks, self.TOLERANCE,
"reduced->%s failure with order %d: %e >= %e"%(fs, order, sup(d[1]+0.5)-3*ranks, self.TOLERANCE))
def test_Rectangle_MPI_construction_single_dimensional(self):
ranks = getMPISizeWorld()
for order in range(2,11):
dom = Rectangle(order, 2, 2*ranks, l1=ranks, d1=ranks)
self.assertEqual(Lsup(dom.getX()[1]+dom.getX()[0]), ranks+1,
"invalid getX() for y-splits order %d"%order)
filt = whereZero(dom.getX()[1] - 1)
for i in range(2,ranks):
filt += whereZero(dom.getX()[1] - i)
if getMPIRankWorld() % 2:
filt *= -1
d = Vector(0, Function(dom))
d[0] = 1 * filt
d[1] = 10 * filt
X = interpolate(d, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res)
self.assertEqual(val, 0,
"summation stage failure for y-splits in order %d"%order)
dom = Rectangle(2, 2*ranks, 2, l0=ranks, d0=ranks)
self.assertEqual(Lsup(dom.getX()[1]+dom.getX()[0]), ranks+1,
"invalid getX() for x-splits order %d"%order)
filt = whereZero(dom.getX()[0] - 1)
for i in range(2,getMPISizeWorld()):
filt += whereZero(dom.getX()[0] - i)
if getMPIRankWorld() % 2:
filt *= -1
d = Vector(0, Function(dom))
d[0] = 1 * filt
d[1] = 10 * filt
X = interpolate(d, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res)
self.assertEqual(val, 0,
"summation stage failure for x-splits in order %d"%order)
X = interpolate(d+2, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res-2)
self.assertEqual(val, 0,
"averaging stage failure for x-splits in order %d"%order)
def test_Rectangle_interpolation_continuous_noncontinuous_and_back(self):
ranks = getMPISizeWorld()
for order in range(2,11):
dom = Rectangle(order, 3, 3*ranks, d1=ranks, l0=6, l1=6)
original = Data(5, Function(dom), True)
cont = interpolate(original, ContinuousFunction(dom))
func = interpolate(cont, Function(dom))
self.assertEqual(Lsup(original-func), 0,
"interpolation of constant, order %d: original and final not equal, %e != 0"%(order, Lsup(original-func)))
x = dom.getX()
original = x[0] + x[1] + 1
cont = interpolate(original, ContinuousFunction(dom))
func = interpolate(cont, Function(dom))
self.assertEqual(Lsup(original-func), 0,
"interpolation of expanded, order %d: original and final not equal, %e != 0"%(order, Lsup(original-func)))
original = whereZero(x[0]-2) + whereZero(x[1]-2)
cont = interpolate(original, ContinuousFunction(dom))
func = interpolate(cont, Function(dom))
self.assertEqual(Lsup(original-func), 0,
"interpolation of point, order %d: original and final not equal, %e != 0"%(order, Lsup(original-func)))
def test_Rectangle_ContinuousFunction_gradient(self):
ranks = getMPISizeWorld()
for order in range(2,11):
dom = Rectangle(order, 3, 3*ranks, d1=ranks, l0=100, l1=100)
X = dom.getX()
u = X[0] + X[1] + 1
v = Lsup(grad(u) - 1)
self.assertLess(v, 1e-10, "order %d, %e >= 1e-10, %s"%(order, v, str(grad(u)-1)))
for power in range(1, order+1):
for power2 in range(1, order+1):
a = X[0]**power * X[1]**power2
da = grad(a)
first = Lsup(da[0] - power*X[0]**(power-1) * X[1]**power2) \
/Lsup(power*X[0]**(power-1) * X[1]**power2)
second = Lsup(da[1] - power2*X[1]**(power2-1) * X[0]**power) \
/Lsup(power2*X[1]**(power2-1) * X[0]**power)
self.assertLess(first, 1e-10,
"order %d and degree %d,%d, %e >= 1e-9"%(order,
power, power2, first))
self.assertLess(second, 1e-10,
"order %d and degree %d,%d, %e >= 1e-9"%(order,
power, power2, second))
def test_Rectangle_ReducedFunction(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Rectangle(order, 3, 3 * ranks, l0=3, l1=3 * ranks, d1=ranks)
X = dom.getX()
redData = interpolate(X, ReducedFunction(dom))
data = [(interpolate(redData,
ReducedFunction(dom)), "ReducedFunction"),
(interpolate(redData, Function(dom)), "Function"),
(interpolate(redData, ContinuousFunction(dom)),
"ContinuousFunction")]
for d, fs in data:
self.assertLess(
inf(d - [0.5] * 2), self.TOLERANCE,
"reduced->%s failure with order %d: %e != 0" %
(fs, order, inf(d - [0.5] * 2)))
self.assertLess(
sup(d[0] + 0.5) - 3, self.TOLERANCE,
"reduced->%s failure with order %d: %e != 3" %
(fs, order, sup(d[0] + 0.5)))
self.assertLess(
sup(d[1] + 0.5) - 3 * ranks, self.TOLERANCE,
"reduced->%s failure with order %d: %e >= %e" %
(fs, order, sup(d[1] + 0.5) - 3 * ranks, self.TOLERANCE))
for iy in range(len(receiver_line)):
rcv_locations.append((mid_point, receiver_line[iy], 0))
rg.append((mid_point, receiver_line[iy]))
#
# create domain:
#
if DIM == 2:
domain = Rectangle(ORDER,
ceil(ne_z * width_x / depth),
ne_z,
l0=width_x,
l1=(-depth, 0),
diracPoints=src_locations,
diracTags=src_tags)
#suppress the x-component on the x boundary
q = whereZero(domain.getX()[0]) * [1, 0]
else:
domain = Brick(ORDER,
ceil(ne_z * width_x / depth),
ceil(ne_z * width_y / depth),
ne_z,
l0=width_x,
l1=width_y,
l2=(-depth, 0),
diracPoints=src_locations,
diracTags=src_tags)
q = wherePositive(
#suppress the x-component on the x boundary
whereZero(domain.getX()[0]) * [1, 0, 0] + #logical or
#suppress the y-component on the y boundary at the source
whereZero(domain.getX()[1]) * [0, 1, 0])
