def test_padding_biharmonic(family):
N = 8
B = FunctionSpace(N, family, bc=(0, 0, 0, 0))
Bp = B.get_dealiased(1.5)
u = Function(B)
u[:(N - 4)] = np.random.random(N - 4)
up = Array(Bp)
up = Bp.backward(u, fast_transform=False)
uf = Bp.forward(up, fast_transform=False)
assert np.linalg.norm(uf - u) < 1e-12
if family == 'C':
up = Bp.backward(u)
uf = Bp.forward(up)
assert np.linalg.norm(uf - u) < 1e-12
# Test padding 2D
F = FunctionSpace(N, 'F', dtype='d')
T = TensorProductSpace(comm, (B, F))
Tp = T.get_dealiased(1.5)
u = Function(T)
u[:-4, :-1] = np.random.random(u[:-4, :-1].shape)
up = Tp.backward(u)
uc = Tp.forward(up)
assert np.linalg.norm(u - uc) < 1e-8
# Test padding 3D
F1 = FunctionSpace(N, 'F', dtype='D')
T = TensorProductSpace(comm, (F1, F, B))
Tp = T.get_dealiased(1.5)
u = Function(T)
u[:, :, :-4] = np.random.random(u[:, :, :-4].shape)
u = u.backward().forward() # Clean
up = Tp.backward(u)
uc = Tp.forward(up)
assert np.linalg.norm(u - uc) < 1e-8
def test_padding_neumann(family):
N = 8
B = FunctionSpace(N, family, bc={'left': ('N', 0), 'right': ('N', 0)})
Bp = B.get_dealiased(1.5)
u = Function(B)
u[1:-2] = np.random.random(N - 3)
up = Array(Bp)
up = Bp.backward(u, fast_transform=False)
uf = Bp.forward(up, fast_transform=False)
assert np.linalg.norm(uf - u) < 1e-12
if family == 'C':
up = Bp.backward(u)
uf = Bp.forward(up)
assert np.linalg.norm(uf - u) < 1e-12
# Test padding 2D
F = FunctionSpace(N, 'F', dtype='d')
T = TensorProductSpace(comm, (B, F))
Tp = T.get_dealiased(1.5)
u = Function(T)
u[1:-2, :-1] = np.random.random(u[1:-2, :-1].shape)
up = Tp.backward(u)
uc = Tp.forward(up)
assert np.linalg.norm(u - uc) < 1e-8
# Test padding 3D
F1 = FunctionSpace(N, 'F', dtype='D')
T = TensorProductSpace(comm, (F1, F, B))
Tp = T.get_dealiased(1.5)
u = Function(T)
u[:, :, 1:-2] = np.random.random(u[:, :, 1:-2].shape)
u = u.backward().forward() # Clean
up = Tp.backward(u)
uc = Tp.forward(up)
assert np.linalg.norm(u - uc) < 1e-8
def test_refine():
assert comm.Get_size() < 7
N = (8, 9, 10)
F0 = Basis(8, 'F', dtype='D')
F1 = Basis(9, 'F', dtype='D')
F2 = Basis(10, 'F', dtype='d')
T = TensorProductSpace(comm, (F0, F1, F2), slab=True, collapse_fourier=True)
u_hat = Function(T)
u = Array(T)
u[:] = np.random.random(u.shape)
u_hat = u.forward(u_hat)
Tp = T.get_dealiased(padding_factor=(2, 2, 2))
u_ = Array(Tp)
up_hat = Function(Tp)
assert up_hat.commsizes == u_hat.commsizes
u2 = u_hat.refine(2*np.array(N))
V = VectorTensorProductSpace(T)
u_hat = Function(V)
u = Array(V)
u[:] = np.random.random(u.shape)
u_hat = u.forward(u_hat)
Vp = V.get_dealiased(padding_factor=(2, 2, 2))
u_ = Array(Vp)
up_hat = Function(Vp)
assert up_hat.commsizes == u_hat.commsizes
u3 = u_hat.refine(2*np.array(N))
def test_padding_orthogonal(family):
N = 8
B = FunctionSpace(N, family)
Bp = B.get_dealiased(1.5)
u = Function(B)
u[:] = np.random.random(u.shape)
up = Array(Bp)
if family != 'F':
up = Bp.backward(u, fast_transform=False)
uf = Bp.forward(up, fast_transform=False)
assert np.linalg.norm(uf - u) < 1e-12
if family in ('C', 'F'):
up = Bp.backward(u, fast_transform=True)
uf = Bp.forward(up, fast_transform=True)
assert np.linalg.norm(uf - u) < 1e-12
# Test padding 2D
dtype = 'D' if family == 'F' else 'd'
F = FunctionSpace(N, 'F', dtype=dtype)
T = TensorProductSpace(comm, (F, B))
Tp = T.get_dealiased(1.5)
u = Function(T)
u[:] = np.random.random(u.shape)
u = u.backward().forward()
up = Tp.backward(u)
uc = Tp.forward(up)
assert np.linalg.norm(u - uc) < 1e-8
# Test padding 3D
F1 = FunctionSpace(N, 'F', dtype='D')
T = TensorProductSpace(comm, (F1, F, B))
Tp = T.get_dealiased(1.5)
u = Function(T)
u[:] = np.random.random(u.shape)
u = u.backward().forward() # Clean
up = Tp.backward(u)
uc = Tp.forward(up)
assert np.linalg.norm(u - uc) < 1e-8
def test_padding(family):
N = 8
B = FunctionSpace(N, family, bc=(-1, 1), domain=(-2, 2))
Bp = B.get_dealiased(1.5)
u = Function(B).set_boundary_dofs()
#u[:(N-2)] = np.random.random(N-2)
u[:(N - 2)] = 1
up = Array(Bp)
up = Bp.backward(u, fast_transform=False)
uf = Bp.forward(up, fast_transform=False)
assert np.linalg.norm(uf - u) < 1e-12
if family == 'C':
up = Bp.backward(u)
uf = Bp.forward(up)
assert np.linalg.norm(uf - u) < 1e-12
# Test padding 2D
F = FunctionSpace(N, 'F', dtype='d')
T = TensorProductSpace(comm, (B, F))
Tp = T.get_dealiased(1.5)
u = Function(T).set_boundary_dofs()
u[:-2, :-1] = np.random.random(u[:-2, :-1].shape)
up = Tp.backward(u)
uc = Tp.forward(up)
assert np.linalg.norm(u - uc) < 1e-8
# Test padding 3D
F1 = FunctionSpace(N, 'F', dtype='D')
T = TensorProductSpace(comm, (F1, F, B))
Tp = T.get_dealiased(1.5)
u = Function(T).set_boundary_dofs()
u[:, :, :-2] = np.random.random(u[:, :, :-2].shape)
u = u.backward().forward() # Clean
up = Tp.backward(u)
uc = Tp.forward(up)
assert np.linalg.norm(u - uc) < 1e-8
ul = lambdify((x, y), u0, modules=['numpy', {'erf': scipy.special.erf}])
vl = lambdify((x, y), v0, modules=['numpy', {'erf': scipy.special.erf}])
# Size of discretization
N = (200, 200)
K0 = Basis(N[0], 'F', dtype='D', domain=(-1., 1.))
K1 = Basis(N[1], 'F', dtype='d', domain=(-1., 1.))
T = TensorProductSpace(comm, (K0, K1))
X = T.local_mesh(True)
u = TrialFunction(T)
v = TestFunction(T)
# For nonlinear term we can use the 3/2-rule with padding
Tp = T.get_dealiased((1.5, 1.5))
# Turn on padding by commenting
#Tp = T
# Create vector spaces and a test function for the regular vector space
TV = VectorTensorProductSpace(T)
TVp = VectorTensorProductSpace(Tp)
vv = TestFunction(TV)
uu = TrialFunction(TV)
# Declare solution arrays and work arrays
UV = Array(TV)
UVp = Array(TVp)
U, V = UV # views into vector components
UV_hat = Function(TV)
def test_transform(typecode, dim):
s = (True,)
if comm.Get_size() > 2 and dim > 2:
s = (True, False)
for slab in s:
for shape in product(*([sizes]*dim)):
bases = []
for n in shape[:-1]:
bases.append(FunctionSpace(n, 'F', dtype=typecode.upper()))
bases.append(FunctionSpace(shape[-1], 'F', dtype=typecode))
fft = TensorProductSpace(comm, bases, dtype=typecode, slab=slab)
if comm.rank == 0:
grid = [c.size for c in fft.subcomm]
print('grid:{} shape:{} typecode:{}'
.format(grid, shape, typecode))
U = random_like(fft.forward.input_array)
F = fft.forward(U)
V = fft.backward(F)
assert allclose(V, U)
# Alternative method
fft.forward.input_array[...] = U
fft.forward(fast_transform=False)
fft.backward(fast_transform=False)
V = fft.backward.output_array
assert allclose(V, U)
TT = VectorSpace(fft)
U = Array(TT)
V = Array(TT)
F = Function(TT)
U[:] = random_like(U)
F = TT.forward(U, F)
V = TT.backward(F, V)
assert allclose(V, U)
TM = CompositeSpace([fft, fft])
U = Array(TM)
V = Array(TM)
F = Function(TM)
U[:] = random_like(U)
F = TM.forward(U, F)
V = TM.backward(F, V)
assert allclose(V, U)
fftp = fft.get_dealiased(padding_factor=1.5)
#fft.destroy()
#padding = 1.5
#bases = []
#for n in shape[:-1]:
# bases.append(FunctionSpace(n, 'F', dtype=typecode.upper(), padding_factor=padding))
#bases.append(FunctionSpace(shape[-1], 'F', dtype=typecode, padding_factor=padding))
#fft = TensorProductSpace(comm, bases, dtype=typecode)
if comm.rank == 0:
grid = [c.size for c in fftp.subcomm]
print('grid:{} shape:{} typecode:{}'
.format(grid, shape, typecode))
U = random_like(fftp.forward.input_array)
F = fftp.forward(U)
Fc = F.copy()
V = fftp.backward(F)
F = fftp.forward(V)
assert allclose(F, Fc)
# Alternative method
fftp.backward.input_array[...] = F
fftp.backward()
fftp.forward()
V = fftp.forward.output_array
assert allclose(F, V)
fftp.destroy()
fft.destroy()
