b = 2
x, y = symbols("x,y")
ue = (cos(4 * np.pi * y) +
sin(2 * x)) * (1 - y**2) + a * (1 + y) / 2. + b * (1 - y) / 2.
fe = ue.diff(x, 2) + ue.diff(y, 2)
# Lambdify for faster evaluation
ul = lambdify((x, y), ue, 'numpy')
fl = lambdify((x, y), fe, 'numpy')
# Size of discretization
N = (eval(sys.argv[-2]), eval(sys.argv[-2]))
SD = Basis(N[1], scaled=True, bc=(a, b))
K1 = R2CBasis(N[0])
T = TensorProductSpace(comm, (K1, SD), axes=(1, 0))
X = T.local_mesh(
True
) # With broadcasting=True the shape of X is local_shape, even though the number of datapoints are still the same as in 1D
u = TrialFunction(T)
v = TestFunction(T)
# Get f on quad points
fj = fl(*X)
# Compute right hand side of Poisson equation
f_hat = Array(T)
f_hat = inner(v, fj, output_array=f_hat)
if basis == 'legendre':
f_hat *= -1.
# Use sympy to compute a rhs, given an analytical solution
x, y, z = symbols("x,y,z")
ue = cos(4 * x) + sin(4 * y) + sin(6 * z)
fe = ue.diff(x, 2) + ue.diff(y, 2) + ue.diff(z, 2)
ul = lambdify((x, y, z), ue, 'numpy')
fl = lambdify((x, y, z), fe, 'numpy')
# Size of discretization
N = (14, 15, 16)
K0 = C2CBasis(N[0])
K1 = C2CBasis(N[1])
K2 = R2CBasis(N[2])
T = TensorProductSpace(comm, (K0, K1, K2))
X = T.local_mesh(
True
) # With broadcasting=True the shape of X is local_shape, even though the number of datapoints are still the same as in 1D
u = TrialFunction(T)
v = TestFunction(T)
# Get f on quad points
fj = fl(*X)
# Compute right hand side
f_hat = inner(v, fj)
# Solve Poisson equation
A = inner(v, div(grad(u)))
f_hat = A.solve(f_hat)
x, y, z = symbols("x,y,z")
ue = (cos(4*x) + sin(2*y) + sin(4*z))*(1-y**2)
fe = ue.diff(x, 2) + ue.diff(y, 2) + ue.diff(z, 2)
# Lambdify for faster evaluation
ul = lambdify((x, y, z), ue, 'numpy')
fl = lambdify((x, y, z), fe, 'numpy')
# Size of discretization
#N = [eval(sys.argv[-1])]*3
SD = Basis(N[0])
K1 = C2CBasis(N[1])
K2 = R2CBasis(N[2])
#T = TensorProductSpace(comm, (SD, K1, K2), axes=(0, 1, 2))
T = TensorProductSpace(comm, (K1, K1, K1), axes=(0, 1, 2))
X = T.local_mesh(True)
u = TrialFunction(T)
v = TestFunction(T)
K = T.local_wavenumbers()
if True:
# inspect data layout
# see poisson3D example on github
print(comm.Get_rank(), ' spectral ', T.local_slice()) # spectral space
print(comm.Get_rank(), ' spectral kx=',K[0][[0,-1],0,0],', ky =',K[1][0,[0,-1],0],' kz =',K[2][0,0,[0,-1]]) # spectral space
print(comm.Get_rank(), ' physical ', T.local_slice(spectral=False)) # physical space
print(comm.Get_rank(), ' physical x=',X[0][[0,-1],0,0],', y =',X[1][0,[0,-1],0],' z =',X[2][0,0,[0,-1]]) # physical space
sys.exit()
sin(4 * z)) * (1 - x**2) + a * (1 + x) / 2. + b * (1 - x) / 2.
fe = ue.diff(x, 2) + ue.diff(y, 2) + ue.diff(z, 2)
# Lambdify for faster evaluation
ul = lambdify((x, y, z), ue, 'numpy')
fl = lambdify((x, y, z), fe, 'numpy')
# Size of discretization
N = eval(sys.argv[-2])
N = [N, N + 1, N + 2]
#N = (14, 15, 16)
SD = Basis(N[0], bc=(a, b))
K1 = C2CBasis(N[1])
K2 = R2CBasis(N[2])
T = TensorProductSpace(comm, (SD, K1, K2), axes=(0, 1, 2), slab=True)
X = T.local_mesh(
) # With broadcasting=True the shape of X is local_shape, even though the number of datapoints are still the same as in 1D
u = TrialFunction(T)
v = TestFunction(T)
K = T.local_wavenumbers()
# Get f on quad points
fj = fl(*X)
# Compute right hand side of Poisson equation
f_hat = inner(v, fj)
if basis == 'legendre':
f_hat *= -1.
# Use sympy to compute a rhs, given an analytical solution
a = 2.
x, y = symbols("x,y")
ue = (cos(4 * y) * sin(2 * x)) * (1 - x**2) * (1 - y**2)
fe = a * ue - ue.diff(x, 2) - ue.diff(y, 2)
# Lambdify for faster evaluation
ul = lambdify((x, y), ue, 'numpy')
fl = lambdify((x, y), fe, 'numpy')
# Size of discretization
N = (32, 34)
SD0 = Basis(N[0], scaled=True)
SD1 = Basis(N[1], scaled=True)
T = TensorProductSpace(comm, (SD0, SD1))
X = T.local_mesh(True)
u = TrialFunction(T)
v = TestFunction(T)
# Get f on quad points
fj = fl(*X)
# Compute right hand side of Poisson equation
f_hat = inner(v, fj)
# Get left hand side of Poisson equation
matrices = inner(grad(v), grad(u))
matrices += inner(v, a * u)
# Create Helmholtz linear algebra solver