def test_Brick_XY_system(self):
ranks = getMPISizeWorld()
for expanded in (True, False):
for order in range(2, 11):
dom = Brick(order, 3, 3 * ranks, 3, l0=6, l1=6, l2=6, d1=ranks)
Y = Data(1, (3, ), Function(dom), expanded)
X = Data(0, (3, 3), Function(dom), expanded)
X[0, 0] = dom.getX()[0]
X[1, 1] = dom.getX()[1]
X[2, 2] = dom.getX()[2]
f = Data(0, (3, ), 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(3):
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 xtest_Brick_interpolation_continuous_noncontinuous_and_back(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Brick(order, 3, 3 * ranks, 3, l0=6, l1=ranks, l2=6, d1=ranks)
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] + x[2] + 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) + whereZero(x[2] - 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_Brick_ReducedFunction(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Brick(order,
3,
3 * ranks,
3,
l0=3,
l1=3 * ranks,
l2=3,
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] * 3), self.TOLERANCE,
"reduced->%s failure with order %d: %e != 0" %
(fs, order, inf(d - [0.5] * 3)))
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))
self.assertLess(
sup(d[2] + 0.5) - 3, self.TOLERANCE,
"reduced->%s failure with order %d: %e != 3" %
(fs, order, sup(d[2] + 0.5)))
def test_Brick_ContinuousFunction_gradient(self):
ranks = getMPISizeWorld()
for order in range(2,11):
dom = Brick(order, 3, 3*ranks, 3, l0=100, l1=100, l2=100, d1=ranks)
X = dom.getX()
u = X[0] + X[1] + X[2] + 1
v = Lsup(grad(u) - 1)
self.assertLess(v, 1e-10, "order %d, %e >= 1e-10, %s"%(order, v,
str(grad(u)-1)))
for power1 in range(1, order+1, order//2):
for power2 in range(1, order+1, order//2):
for power3 in range(1, order+1, order//2):
a = X[0]**power1 * X[1]**power2 * X[2]**power3
da = grad(a)
temp = power1*X[0]**(power1-1) * X[1]**power2*X[2]**power3
first = Lsup(da[0] - temp) / Lsup(temp)
temp = power2*X[1]**(power2-1) * X[0]**power1*X[2]**power3
second = Lsup(da[1] - temp) / Lsup(temp)
temp = power3*X[2]**(power3-1) * X[0]**power1*X[1]**power2
third = Lsup(da[2] - temp) / Lsup(temp)
self.assertLess(first, 1e-10,
"order %d and degree %d,%d,%d, %e >= 1e-9"%(order,
power1, power2, power3, first))
self.assertLess(second, 1e-10,
"order %d and degree %d,%d,%d, %e >= 1e-9"%(order,
power1, power2, power3, second))
self.assertLess(third, 1e-10,
"order %d and degree %d,%d,%d, %e >= 1e-9"%(order,
power1, power2, power3, third))
def xtest_Brick_singledim_subdivision(self):
ranks = getMPISizeWorld()
for dim in range(0, 3):
label = ["x", "y", "z"][dim]
size = [2, 2, 2]
size[dim] *= ranks
lengths = [1, 1, 1]
lengths[dim] *= ranks
splits = [1, 1, 1]
splits[dim] *= ranks
for order in range(2, 11):
dom = Brick(order,
size[0],
size[1],
size[2],
l0=lengths[0],
l1=lengths[1],
l2=lengths[2],
d0=splits[0],
d1=splits[1],
d2=splits[2])
self.assertEqual(Lsup(dom.getX()[1]+dom.getX()[0]+dom.getX()[2]),
ranks+2, "invalid getX() for %s-splits order %d"%(\
label, order))
filt = whereZero(dom.getX()[dim] - 1)
for i in range(2, ranks):
filt += whereZero(dom.getX()[0] - i)
if getMPIRankWorld() % 2:
filt *= -1
d = Vector(0, Function(dom))
d[0] = 1 * filt
d[1] = 10 * filt
d[2] = 100 * filt
X = interpolate(d, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res)
self.assertEqual(val, 0,
"summation stage failure for %s-splits in order %d,"%(\
label, order))
X = interpolate(d + 2, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res - 2)
self.assertEqual(val, 0,
"averaging stage failure for %s-splits in order %d,"%(\
label, order))
def test_Brick_singledim_subdivision(self):
ranks = getMPISizeWorld()
for dim in range(0,3):
label = ["x","y","z"][dim]
size = [2,2,2]
size[dim] *= ranks
lengths = [1,1,1]
lengths[dim] *= ranks
splits = [1,1,1]
splits[dim] *= ranks
for order in range(2, 11):
dom = Brick(order, size[0], size[1], size[2],
l0=lengths[0], l1=lengths[1], l2=lengths[2],
d0=splits[0], d1=splits[1], d2=splits[2])
self.assertEqual(Lsup(dom.getX()[1]+dom.getX()[0]+dom.getX()[2]),
ranks+2, "invalid getX() for %s-splits order %d"%(\
label, order))
filt = whereZero(dom.getX()[dim] - 1)
for i in range(2,ranks):
filt += whereZero(dom.getX()[0] - i)
if getMPIRankWorld() % 2:
filt *= -1
d = Vector(0, Function(dom))
d[0] = 1 * filt
d[1] = 10 * filt
d[2] = 100 * filt
X = interpolate(d, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res)
self.assertEqual(val, 0,
"summation stage failure for %s-splits in order %d,"%(\
label, order))
X = interpolate(d+2, Function(dom))
res = interpolate(X, ContinuousFunction(dom))
val = Lsup(res-2)
self.assertEqual(val, 0,
"averaging stage failure for %s-splits in order %d,"%(\
label, order))
def test_Brick_XY_single(self):
ranks = getMPISizeWorld()
for expanded in (True, False):
for order in range(2,11):
dom = Brick(order, 3, 3*ranks, 3, l0=6, l1=6, l2=6, d1=ranks)
Y = Data(3, Function(dom), expanded)
X = Data(0, (3,), Function(dom), expanded)
X[0] = dom.getX()[0]
X[1] = dom.getX()[1]
X[2] = dom.getX()[2]
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(3):
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_Brick_integration(self):
ranks = getMPISizeWorld()
for order in range(2,11):
size = 6
dom = Brick(order, 3, 3*ranks, 3, l0=6, l1=6, l2=6, d1=ranks)
X = dom.getX()
for k in [1, order, order*2 - 1]:
for l in [1, order, order*2 - 1]:
for m in [1, order, order*2 - 1]:
powered = X[0]**k * X[1]**l * X[2]**m
integral = integrate(powered)
actual = size**(k+1) * size**(l+1) * size**(m+1) \
/((k+1.)*(l+1.)*(m+1.))
res = abs(integral - actual)/actual
self.assertLess(res, 1e-11,
"too much variance in integral result (order %d, degrees %d %d, %e >= 1e-11)"%(order,
k, l, res))
def test_Brick_ContinuousFunction_gradient(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Brick(order,
3,
3 * ranks,
3,
l0=100,
l1=100,
l2=100,
d1=ranks)
X = dom.getX()
u = X[0] + X[1] + X[2] + 1
v = Lsup(grad(u) - 1)
self.assertLess(
v, 1e-10,
"order %d, %e >= 1e-10, %s" % (order, v, str(grad(u) - 1)))
for power1 in range(1, order + 1, order // 2):
for power2 in range(1, order + 1, order // 2):
for power3 in range(1, order + 1, order // 2):
a = X[0]**power1 * X[1]**power2 * X[2]**power3
da = grad(a)
temp = power1 * X[0]**(power1 -
1) * X[1]**power2 * X[2]**power3
first = Lsup(da[0] - temp) / Lsup(temp)
temp = power2 * X[1]**(power2 -
1) * X[0]**power1 * X[2]**power3
second = Lsup(da[1] - temp) / Lsup(temp)
temp = power3 * X[2]**(power3 -
1) * X[0]**power1 * X[1]**power2
third = Lsup(da[2] - temp) / Lsup(temp)
self.assertLess(
first, 1e-10,
"order %d and degree %d,%d,%d, %e >= 1e-9" %
(order, power1, power2, power3, first))
self.assertLess(
second, 1e-10,
"order %d and degree %d,%d,%d, %e >= 1e-9" %
(order, power1, power2, power3, second))
self.assertLess(
third, 1e-10,
"order %d and degree %d,%d,%d, %e >= 1e-9" %
(order, power1, power2, power3, third))
def xtest_Brick_integration(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
size = 6
dom = Brick(order, 3, 3 * ranks, 3, l0=6, l1=6, l2=6, d1=ranks)
X = dom.getX()
for k in [1, order, order * 2 - 1]:
for l in [1, order, order * 2 - 1]:
for m in [1, order, order * 2 - 1]:
powered = X[0]**k * X[1]**l * X[2]**m
integral = integrate(powered)
actual = size**(k+1) * size**(l+1) * size**(m+1) \
/((k+1.)*(l+1.)*(m+1.))
res = abs(integral - actual) / actual
self.assertLess(
res, 1e-11,
"too much variance in integral result (order %d, degrees %d %d, %e >= 1e-11)"
% (order, k, l, res))
def test_Brick_ReducedFunction(self):
ranks = getMPISizeWorld()
for order in range(2, 11):
dom = Brick(order, 3, 3*ranks, 3, l0=3, l1=3*ranks, l2=3, 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]*3), self.TOLERANCE,
"reduced->%s failure with order %d: %e != 0"%(fs, order, inf(d-[0.5]*3)))
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))
self.assertLess(sup(d[2]+0.5) - 3, self.TOLERANCE,
"reduced->%s failure with order %d: %e != 3"%(fs, order, sup(d[2]+0.5)))
def test_Brick_interpolation_continuous_noncontinuous_and_back(self):
ranks = getMPISizeWorld()
for order in range(2,11):
dom = Brick(order, 3, 3*ranks, 3, l0=6, l1=ranks, l2=6, d1=ranks)
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] + x[2] + 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) + whereZero(x[2] - 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 xtest_Brick_MPI_construction(self):
for order in range(2, 11):
dom = Brick(order,
2 * getMPISizeWorld(),
2,
2,
d0=getMPISizeWorld())
self.assertEqual(
Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]), 3,
"invalid Lsup(getX()) for x-split order %d" % order)
X = interpolate(dom.getX()[0], Function(dom)) \
+ interpolate(dom.getX()[1], Function(dom))
val = Lsup(interpolate(X, ContinuousFunction(dom)) \
- (dom.getX()[0] + dom.getX()[1]))
self.assertLess(
val, 1e-10,
"interpolation failure for x-split order %d" % order)
dom = Brick(order,
2,
2 * getMPISizeWorld(),
2,
d1=getMPISizeWorld())
self.assertEqual(
Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]), 3,
"invalid Lsup(getX()) for y-split order %d" % order)
X = interpolate(dom.getX()[0], Function(dom)) \
+ interpolate(dom.getX()[1], Function(dom))
val = Lsup(interpolate(X, ContinuousFunction(dom)) \
- (dom.getX()[0] + dom.getX()[1]))
self.assertLess(
val, 1e-10,
"interpolation failure for y-split order %d" % order)
dom = Brick(order,
2,
2,
2 * getMPISizeWorld(),
d2=getMPISizeWorld())
self.assertEqual(
Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]), 3,
"invalid Lsup(getX()) for z-split order %d" % order)
X = interpolate(dom.getX()[0], Function(dom)) \
+ interpolate(dom.getX()[1], Function(dom))
val = Lsup(interpolate(X, ContinuousFunction(dom)) \
- (dom.getX()[0] + dom.getX()[1]))
self.assertLess(
val, 1e-10,
"interpolation failure for z-split order %d" % order)
def test_Brick_MPI_construction(self):
for order in range(2,11):
dom = Brick(order, 2*getMPISizeWorld(), 2, 2, d0=getMPISizeWorld())
self.assertEqual(Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]),
3, "invalid Lsup(getX()) for x-split order %d"%order)
X = interpolate(dom.getX()[0], Function(dom)) \
+ interpolate(dom.getX()[1], Function(dom))
val = Lsup(interpolate(X, ContinuousFunction(dom)) \
- (dom.getX()[0] + dom.getX()[1]))
self.assertLess(val, 1e-10,
"interpolation failure for x-split order %d"%order)
dom = Brick(order, 2, 2*getMPISizeWorld(), 2, d1=getMPISizeWorld())
self.assertEqual(Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]),
3, "invalid Lsup(getX()) for y-split order %d"%order)
X = interpolate(dom.getX()[0], Function(dom)) \
+ interpolate(dom.getX()[1], Function(dom))
val = Lsup(interpolate(X, ContinuousFunction(dom)) \
- (dom.getX()[0] + dom.getX()[1]))
self.assertLess(val, 1e-10,
"interpolation failure for y-split order %d"%order)
dom = Brick(order, 2, 2, 2*getMPISizeWorld(), d2=getMPISizeWorld())
self.assertEqual(Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]),
3, "invalid Lsup(getX()) for z-split order %d"%order)
X = interpolate(dom.getX()[0], Function(dom)) \
+ interpolate(dom.getX()[1], Function(dom))
val = Lsup(interpolate(X, ContinuousFunction(dom)) \
- (dom.getX()[0] + dom.getX()[1]))
self.assertLess(val, 1e-10,
"interpolation failure for z-split order %d"%order)
