def test_Rectangle_Function_gradient_Simetric(
self): #expanded and non-expanded
ranks = getMPISizeWorld()
for expanded in [True, False]:
for order in range(2, 11):
dom = Rectangle(order, 3, 3 * ranks, d1=ranks)
x = ContinuousFunction(dom).getX()
m = -2 * 1j + 4
b = 3 + 8 * 1j
f = Vector(0., Solution(dom))
sample_data = [[
0.000000000 + 0.000000000j, 4.000000000 - 2.000000000j
], [4.000000000 - 2.000000000j, 8.000000000 - 4.000000000j]]
sample = Data(sample_data, Function(dom), True)
sample[0, 0] = 0.000000000 + 0.000000000j
sample[0, 1] = 4.000000000 - 2.000000000j
sample[1, 0] = 4.000000000 - 2.000000000j
sample[1, 1] = 8.000000000 - 4.000000000j
for i in range(dom.getDim()):
for j in range(dom.getDim()):
f[i] += m * (i + j) * x[j] + b - i * j
g = grad(f)
self.assertLess(
Lsup(g - sample), 1e-9,
"single component failure, order %d%s, %e >= 1e-10" %
(order,
(" expanded" if expanded else ""), Lsup(g - sample)))
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_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_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_Du_Y_system(self):
#solves for u in Du = Y, where D = [1,2], Y = [2,4]
ranks = getMPISizeWorld()
for expanded in (True, False):
for order in range(2, 11):
dom = Rectangle(order, 3, 3 * ranks, d1=ranks)
D = Data(1, (2, ), ContinuousFunction(dom), expanded)
D[1] = 2
Y = Data(2, (2, ), ContinuousFunction(dom), expanded)
Y[1] = 4
Y = interpolate(Y, Function(dom))
D = interpolate(D, Function(dom))
rhs = Data(0, (2, ), Solution(dom), expanded)
lhs = Data(0, (2, ), Solution(dom), expanded)
dom.addToRHS(rhs, [("Y", Y)],
dom.createAssembler("DefaultAssembler", []))
dom.addToRHS(lhs, [("D", D)],
dom.createAssembler("DefaultAssembler", []))
res = Lsup((rhs / lhs) - 2)
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_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_complex_params_Rectangle(self):
domain=Rectangle(order=2,n0=10,n1=10)
pde = LinearSinglePDE(domain, isComplex=True)
pde.setValue(D=1j)
pde.setValue(Y=1.0)
self.assertTrue(Lsup(pde.getSolution())==1.0, "Failed test_complex_params_Rectangle")
del domain
def test_Rectangle_Du_Y_system(self):
#solves for u in Du = Y, where D = [1,2], Y = [2,4]
ranks = getMPISizeWorld()
for expanded in (True, False):
for order in range(2,11):
dom = Rectangle(order, 3, 3*ranks, d1=ranks)
D = Data(1, (2,), ContinuousFunction(dom), expanded)
D[1] = 2
Y = Data(2, (2,), ContinuousFunction(dom), expanded)
Y[1] = 4
Y = interpolate(Y, Function(dom))
D = interpolate(D, Function(dom))
rhs = Data(0, (2,), Solution(dom), expanded)
lhs = Data(0, (2,), Solution(dom), expanded)
dom.addToRHS(rhs, [("Y",Y)],
dom.createAssembler("DefaultAssembler", []))
dom.addToRHS(lhs, [("D",D)],
dom.createAssembler("DefaultAssembler", []))
res = Lsup((rhs/lhs)-2)
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 generateRects(self, order, a, b):
rectX = Rectangle(order,
self.longEdge,
self.shortEdge,
l0=self.longEdge,
l1=self.shortEdge,
d0=self.numRanks,
diracPoints=[(a, b)],
diracTags=["test"])
rectY = Rectangle(order,
self.shortEdge,
self.longEdge,
l0=self.shortEdge,
l1=self.longEdge,
d1=self.numRanks,
diracPoints=[(b, a)],
diracTags=["test"])
return [rectX, rectY]
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 setUp(self):
self.domains = []
for order in range(2, 11):
self.domains.append(
Rectangle(order,
10,
10,
l0=100,
l1=100,
diracTags=["source"],
diracPoints=[(0, 0)]))
self.wavelet = Ricker(100.)
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_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_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))
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_Function_gradient(self): #expanded and non-expanded
ranks = getMPISizeWorld()
for expanded in [True, False]:
for order in range(2, 11):
dom = Rectangle(order, 3, 3 * ranks, d1=ranks)
x = Data(5, Function(dom), True)
self.assertLess(
Lsup(grad(x)), 1e-10,
"single component failure, order %d%s, %e >= 1e-10" %
(order, (" expanded" if expanded else ""), Lsup(grad(x))))
for data in [[5, 1], [-5, -1], [5, 1, 1e-5]]:
x = Data(data, Function(dom), True)
g = grad(x)
for n, d in enumerate(data):
self.assertLess(
Lsup(g[n]), 1e-10,
"%d-component failure, order %d %sexpanded, %e >= 1e-10"
% (len(data), order,
("" if expanded else "un-"), Lsup(g[n])))
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 test_Creation(self):
r = self.numRanks
el = self.numRanks * 3
#test bad types
with self.assertRaises(TypeError):
Rectangle(2, 5, el, d1=r, diracPoints=(.0, 0.), diracTags=["test"])
with self.assertRaises(TypeError):
Rectangle(2,
5,
el,
d1=r,
diracPoints=[(.0, 0.)],
diracTags=("test"))
with self.assertRaises(TypeError):
Rectangle(2, 5, el, d1=r, diracPoints=[.0], diracTags=["test"])
with self.assertRaises(TypeError):
Rectangle(2, 5, el, d1=r, diracPoints=[.0, .0], diracTags=["test"])
with self.assertRaises(TypeError):
Brick(2,
5,
el,
5,
d1=r,
diracPoints=(.0, 0., 0.),
diracTags=["test"])
with self.assertRaises(TypeError):
Brick(2,
5,
el,
5,
d1=r,
diracPoints=[(.0, 0., 0.)],
diracTags=("test"))
with self.assertRaises(TypeError):
Brick(2, 5, el, 5, d1=r, diracPoints=[.0, 0.], diracTags=["test"])
#test bad arg lengths
with self.assertRaises(RuntimeError):
Rectangle(2, 5, el, d1=r, diracPoints=[(.0, )], diracTags=["test"])
with self.assertRaises(RuntimeError):
Rectangle(2, 5, el, d1=r, diracPoints=[(.0, 1.)], diracTags=[])
with self.assertRaises(RuntimeError):
Rectangle(2,
5,
el,
d1=r,
diracPoints=[(.0, 0.)],
diracTags=["test", "break"])
with self.assertRaises(RuntimeError):
Rectangle(2,
5,
el,
d1=r,
diracPoints=[(.0, 0., 0.)],
diracTags=["test"])
with self.assertRaises(RuntimeError):
Brick(2,
5,
el,
5,
d1=r,
diracPoints=[(.0, 0., 0., 0.)],
diracTags=["test"])
with self.assertRaises(RuntimeError):
Brick(2,
5,
el,
5,
d1=r,
diracPoints=[(
.0,
0.,
)],
diracTags=["test"])
with self.assertRaises(RuntimeError):
Brick(2, 5, el, 5, d1=r, diracPoints=[(.0, )], diracTags=["test"])
rcvEW_locations.append((receiver_line[ix], 0, 0))
rcvNS_locations.append((0, receiver_line[ix], 0))
rgNS.append((0, receiver_line[ix]))
# North-south line of receivers
if DIM == 3:
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)
if DIM == 3:
rcvNS_locations = []
rgNS = []
for iy in range(len(receiver_line)):
rcvNS_locations.append((mid_point, receiver_line[iy], depth))
rgNS.append((mid_point, receiver_line[iy]))
#
# create domain:
#
order = 5
if DIM == 2:
domain = Rectangle(order,
ceil(ne_z * width_x / depth),
ne_z,
l0=width_x,
l1=depth,
diracPoints=src_locations,
diracTags=src_tags)
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,
diracPoints=src_locations,
diracTags=src_tags)
wl = Ricker(frq)
m = whereNegative(Function(domain).getX()[DIM - 1] - reflector_at)
print("last receiver location = %s m" % (receiver_line[-1], ))
print("source location = %s m" % (src_locations[0][0], ))
print("source orientation = %s" % (src_dir, ))
print("matrix lumping = %s" % (lumping, ))
print("Layer\tV_p\tV_s\teps\tdelta\ttilt\trho")
for i in range(len(layers)):
print("%s\t%s\t%s\t%s\t%s\t%s\t%s" %
(layers[i], v_P[i], v_S[i], eps[i], delta[i], tilt[i], rho[i]))
#
# create domain:
#
order = 5
domain = Rectangle(order,
ne_x,
ne_z,
l0=width_x,
l1=depth,
diracPoints=src_locations,
diracTags=src_tags,
d0=getMPISizeWorld())
#
# create the wavelet:
#
wl = Ricker(frq)
#
#======================================================================
#
# set
#
z = ReducedFunction(domain).getX()[1]
z_top = 0
V_P = 0
