def test_curl_cc():
theta, phi = sp.symbols('x,y', real=True, positive=True)
psi = (theta, phi)
r = 1
rv = (r * sp.sin(theta) * sp.cos(phi), r * sp.sin(theta) * sp.sin(phi),
r * sp.cos(theta))
# Manufactured solution
sph = sp.functions.special.spherical_harmonics.Ynm
ue = sph(6, 3, theta, phi)
N, M = 16, 12
L0 = FunctionSpace(N, 'C', domain=(0, np.pi))
F1 = FunctionSpace(M, 'F', dtype='D')
T = TensorProductSpace(comm, (L0, F1), coordinates=(psi, rv))
u_hat = Function(T, buffer=ue)
du = curl(grad(u_hat))
du.terms() == [[]]
r, theta, z = psi = sp.symbols('x,y,z', real=True, positive=True)
rv = (r * sp.cos(theta), r * sp.sin(theta), z)
# Manufactured solution
ue = (r * (1 - r) * sp.cos(4 * theta) - 1 * (r - 1)) * sp.cos(4 * z)
N = 12
F0 = FunctionSpace(N, 'F', dtype='D')
F1 = FunctionSpace(N, 'F', dtype='d')
L = FunctionSpace(N, 'L', bc='Dirichlet', domain=(0, 1))
T = TensorProductSpace(comm, (L, F0, F1), coordinates=(psi, rv))
T1 = T.get_orthogonal()
V = VectorSpace(T1)
u_hat = Function(T, buffer=ue)
du = project(curl(grad(u_hat)), V)
assert np.linalg.norm(du) < 1e-10
def test_inner():
v = shenfun.TestFunction(TT)
u = shenfun.TrialFunction(TT)
p = shenfun.TrialFunction(T)
q = shenfun.TestFunction(T)
inner(div(u), div(v))
inner(grad(u), grad(v))
inner(q, div(u))
inner(curl(v), curl(u))
inner(grad(q), grad(p))
inner(v, grad(div(u)))
inner(q, u[0])
inner(q, u[1])
inner(q, grad(p)[0])
inner(q, grad(p)[1])
inner(v, grad(u)[0])
inner(v, grad(u)[1])
wq = shenfun.TrialFunction(VT)
w, q = wq
hf = shenfun.TestFunction(VT)
h, f = hf
inner(h, div(grad(w)))
inner(f, div(div(grad(w))))
inner(h, curl(w))
inner(curl(h), curl(w))
inner(h, grad(div(w)))
qw = shenfun.TrialFunction(WT)
q, w = qw
fh = shenfun.TestFunction(WT)
f, h = fh
inner(h, div(grad(w)))
inner(f, div(div(grad(w))))
inner(h, curl(w))
inner(curl(h), curl(w))
inner(h, grad(div(w)))
def test_curl(typecode):
K0 = Basis(N[0], 'F', dtype=typecode.upper())
K1 = Basis(N[1], 'F', dtype=typecode.upper())
K2 = Basis(N[2], 'F', dtype=typecode)
T = TensorProductSpace(comm, (K0, K1, K2), dtype=typecode)
X = T.local_mesh(True)
K = T.local_wavenumbers()
Tk = VectorTensorProductSpace(T)
u = TrialFunction(Tk)
v = TestFunction(Tk)
U = Array(Tk)
U_hat = Function(Tk)
curl_hat = Function(Tk)
curl_ = Array(Tk)
# Initialize a Taylor Green vortex
U[0] = np.sin(X[0]) * np.cos(X[1]) * np.cos(X[2])
U[1] = -np.cos(X[0]) * np.sin(X[1]) * np.cos(X[2])
U[2] = 0
U_hat = Tk.forward(U, U_hat)
Uc = U_hat.copy()
U = Tk.backward(U_hat, U)
U_hat = Tk.forward(U, U_hat)
assert allclose(U_hat, Uc)
divu_hat = project(div(U_hat), T)
divu = Array(T)
divu = T.backward(divu_hat, divu)
assert allclose(divu, 0)
curl_hat[0] = 1j * (K[1] * U_hat[2] - K[2] * U_hat[1])
curl_hat[1] = 1j * (K[2] * U_hat[0] - K[0] * U_hat[2])
curl_hat[2] = 1j * (K[0] * U_hat[1] - K[1] * U_hat[0])
curl_ = Tk.backward(curl_hat, curl_)
w_hat = Function(Tk)
w_hat = inner(v, curl(U_hat), output_array=w_hat)
A = inner(v, u)
for i in range(3):
w_hat[i] = A[i].solve(w_hat[i])
w = Array(Tk)
w = Tk.backward(w_hat, w)
#from IPython import embed; embed()
assert allclose(w, curl_)
u_hat = Function(Tk)
u_hat = inner(v, U, output_array=u_hat)
for i in range(3):
u_hat[i] = A[i].solve(u_hat[i])
uu = Array(Tk)
uu = Tk.backward(u_hat, uu)
assert allclose(u_hat, U_hat)
def test_inner():
v = shenfun.TestFunction(TT)
u = shenfun.TrialFunction(TT)
p = shenfun.TrialFunction(T)
q = shenfun.TestFunction(T)
A = inner(div(u), div(v))
B = inner(grad(u), grad(v))
C = inner(q, div(u))
D = inner(curl(v), curl(u))
E = inner(grad(q), grad(p))
F = inner(v, grad(div(u)))
wq = shenfun.TrialFunction(VT)
w, q = wq
hf = shenfun.TestFunction(VT)
h, f = hf
G = inner(h, div(grad(w)))
H = inner(f, div(div(grad(w))))
I = inner(h, curl(w))
J = inner(curl(h), curl(w))
K = inner(h, grad(div(w)))
def test_curl2():
# Test projection of curl
K0 = FunctionSpace(N[0], 'C', bc=(0, 0))
K1 = FunctionSpace(N[1], 'F', dtype='D')
K2 = FunctionSpace(N[2], 'F', dtype='d')
K3 = FunctionSpace(N[0], 'C')
T = TensorProductSpace(comm, (K0, K1, K2))
TT = TensorProductSpace(comm, (K3, K1, K2))
X = T.local_mesh(True)
K = T.local_wavenumbers(False)
Tk = VectorSpace(T)
TTk = VectorSpace([T, T, TT])
U = Array(Tk)
U_hat = Function(Tk)
curl_hat = Function(TTk)
curl_ = Array(TTk)
# Initialize a Taylor Green vortex
U[0] = np.sin(X[0]) * np.cos(X[1]) * np.cos(X[2]) * (1 - X[0]**2)
U[1] = -np.cos(X[0]) * np.sin(X[1]) * np.cos(X[2]) * (1 - X[0]**2)
U[2] = 0
U_hat = Tk.forward(U, U_hat)
Uc = U_hat.copy()
U = Tk.backward(U_hat, U)
U_hat = Tk.forward(U, U_hat)
assert allclose(U_hat, Uc)
# Compute curl first by computing each term individually
curl_hat[0] = 1j * (K[1] * U_hat[2] - K[2] * U_hat[1])
curl_[0] = T.backward(
curl_hat[0], curl_[0]) # No x-derivatives, still in Dirichlet space
dwdx_hat = project(Dx(U_hat[2], 0, 1), TT) # Need to use space without bc
dvdx_hat = project(Dx(U_hat[1], 0, 1), TT) # Need to use space without bc
dwdx = Array(TT)
dvdx = Array(TT)
dwdx = TT.backward(dwdx_hat, dwdx)
dvdx = TT.backward(dvdx_hat, dvdx)
curl_hat[1] = 1j * K[2] * U_hat[0]
curl_hat[2] = -1j * K[1] * U_hat[0]
curl_[1] = T.backward(curl_hat[1], curl_[1])
curl_[2] = T.backward(curl_hat[2], curl_[2])
curl_[1] -= dwdx
curl_[2] += dvdx
# Now do it with project
w_hat = project(curl(U_hat), TTk)
w = Array(TTk)
w = TTk.backward(w_hat, w)
assert allclose(w, curl_)
def test_vector_laplace(space):
"""Test that
div(grad(u)) = grad(div(u)) - curl(curl(u))
"""
T = get_function_space(space)
V = VectorSpace(T)
u = TrialFunction(V)
v = _TestFunction(V)
du = div(grad(u))
dv = grad(div(u)) - curl(curl(u))
u_hat = Function(V)
u_hat[:] = np.random.random(u_hat.shape) + np.random.random(u_hat.shape)*1j
A0 = inner(v, du)
A1 = inner(v, dv)
a0 = BlockMatrix(A0)
a1 = BlockMatrix(A1)
b0 = Function(V)
b1 = Function(V)
b0 = a0.matvec(u_hat, b0)
b1 = a1.matvec(u_hat, b1)
assert np.linalg.norm(b0-b1) < 1e-8
def compute_curl(curl_dealias, u_hat, VCp, curl_hat, work, K):
curl_hat[:] = 0
curl_hat = project(curl(u_hat), VCp, output_array=curl_hat)
curl_dealias = curl_hat.backward(curl_dealias)
return curl_dealias
from shenfun.chebyshev.bases import ShenBiharmonicBasis from shenfun.fourier.bases import R2CBasis, C2CBasis from shenfun import Function, TensorProductSpace, VectorTensorProductSpace, curl from shenfun import inner, curl, TestFunction import numpy as np from mpi4py import MPI comm = MPI.COMM_WORLD N = (32, 33, 34) K0 = ShenBiharmonicBasis(N[0]) K1 = C2CBasis(N[1]) K2 = R2CBasis(N[2]) T = TensorProductSpace(comm, (K0, K1, K2)) Tk = VectorTensorProductSpace([T, T, T]) v = TestFunction(Tk) u_ = Function(Tk, False) u_[:] = np.random.random(u_.shape) u_hat = Function(Tk) u_hat = Tk.forward(u_, u_hat) w_hat = inner(v, curl(u_), uh_hat=u_hat)
