def test_curl2():
# Test projection of curl
K0 = Basis(N[0], 'C', bc=(0, 0))
K1 = Basis(N[1], 'F', dtype='D')
K2 = Basis(N[2], 'F', dtype='d')
K3 = Basis(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 = VectorTensorProductSpace(T)
TTk = MixedTensorProductSpace([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_mixed_2D(backend, forward_output, as_scalar):
if (backend == 'netcdf4' and forward_output is True) or skip[backend]:
return
K0 = FunctionSpace(N[0], 'F')
K1 = FunctionSpace(N[1], 'C')
T = TensorProductSpace(comm, (K0, K1))
TT = MixedTensorProductSpace([T, T])
filename = 'test2Dm_{}'.format(ex[forward_output])
hfile = writer(filename, TT, backend=backend)
if forward_output:
uf = Function(TT, val=2)
else:
uf = Array(TT, val=2)
hfile.write(0, {'uf': [uf]}, as_scalar=as_scalar)
hfile.write(1, {'uf': [uf]}, as_scalar=as_scalar)
if not forward_output and backend == 'hdf5' and comm.Get_rank() == 0:
generate_xdmf(filename + '.h5')
if as_scalar is False:
u0 = Function(TT) if forward_output else Array(TT)
read = reader(filename, TT, backend=backend)
read.read(u0, 'uf', step=1)
assert np.allclose(u0, uf)
else:
u0 = Function(T) if forward_output else Array(T)
read = reader(filename, T, backend=backend)
read.read(u0, 'uf0', step=1)
assert np.allclose(u0, uf[0])
def get_context():
float, complex, mpitype = datatypes(params.precision)
collapse_fourier = False if params.dealias == '3/2-rule' else True
dim = len(params.N)
dtype = lambda d: float if d == dim - 1 else complex
V = [
Basis(params.N[i], 'F', domain=(0, params.L[i]), dtype=dtype(i))
for i in range(dim)
]
kw0 = {
'threads': params.threads,
'planner_effort': params.planner_effort['fft']
}
T = TensorProductSpace(comm,
V,
dtype=float,
slab=(params.decomposition == 'slab'),
collapse_fourier=collapse_fourier,
**kw0)
VT = VectorTensorProductSpace(T)
VM = MixedTensorProductSpace([T] * 2 * dim)
mask = T.mask_nyquist() if params.mask_nyquist else None
kw = {
'padding_factor': 1.5 if params.dealias == '3/2-rule' else 1,
'dealias_direct': params.dealias == '2/3-rule'
}
Vp = [
Basis(params.N[i], 'F', domain=(0, params.L[i]), dtype=dtype(i), **kw)
for i in range(dim)
]
Tp = TensorProductSpace(comm,
Vp,
dtype=float,
slab=(params.decomposition == 'slab'),
collapse_fourier=collapse_fourier,
**kw0)
VTp = VectorTensorProductSpace(Tp)
VMp = MixedTensorProductSpace([Tp] * 2 * dim)
# Mesh variables
X = T.local_mesh(True)
K = T.local_wavenumbers(scaled=True)
for i in range(dim):
X[i] = X[i].astype(float)
K[i] = K[i].astype(float)
K2 = np.zeros(T.shape(True), dtype=float)
for i in range(dim):
K2 += K[i] * K[i]
# Set Nyquist frequency to zero on K that is, from now on, used for odd derivatives
Kx = T.local_wavenumbers(scaled=True, eliminate_highest_freq=True)
for i in range(dim):
Kx[i] = Kx[i].astype(float)
K_over_K2 = np.zeros(VT.shape(True), dtype=float)
for i in range(dim):
K_over_K2[i] = K[i] / np.where(K2 == 0, 1, K2)
UB = Array(VM)
P = Array(T)
curl = Array(VT)
UB_hat = Function(VM)
P_hat = Function(T)
dU = Function(VM)
Source = Array(VM)
ub_dealias = Array(VMp)
ZZ_hat = np.zeros((3, 3) + Tp.shape(True), dtype=complex) # Work array
# Create views into large data structures
U = UB[:3]
U_hat = UB_hat[:3]
B = UB[3:]
B_hat = UB_hat[3:]
# Primary variable
u = UB_hat
hdf5file = MHDFile(config.params.solver,
checkpoint={
'space': VM,
'data': {
'0': {
'UB': [UB_hat]
}
}
},
results={
'space': VM,
'data': {
'UB': [UB]
}
})
return config.AttributeDict(locals())
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(Basis(n, 'F', dtype=typecode.upper()))
bases.append(Basis(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 = VectorTensorProductSpace(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 = MixedTensorProductSpace([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)
fft.destroy()
padding = 1.5
bases = []
for n in shape[:-1]:
bases.append(
Basis(n,
'F',
dtype=typecode.upper(),
padding_factor=padding))
bases.append(
Basis(shape[-1], 'F', dtype=typecode, padding_factor=padding))
fft = TensorProductSpace(comm, bases, dtype=typecode)
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)
Fc = F.copy()
V = fft.backward(F)
F = fft.forward(V)
assert allclose(F, Fc)
# Alternative method
fft.backward.input_array[...] = F
fft.backward()
fft.forward()
V = fft.forward.output_array
assert allclose(F, V)
fft.destroy()
def get_context():
"""Set up context for Bq2D solver"""
float, complex, mpitype = datatypes(params.precision)
collapse_fourier = False if params.dealias == '3/2-rule' else True
dim = len(params.N)
dtype = lambda d: float if d == dim - 1 else complex
V = [
FunctionSpace(params.N[i],
'F',
domain=(0, params.L[i]),
dtype=dtype(i)) for i in range(dim)
]
kw0 = {
'threads': params.threads,
'planner_effort': params.planner_effort['fft']
}
T = TensorProductSpace(comm,
V,
dtype=float,
slab=(params.decomposition == 'slab'),
collapse_fourier=collapse_fourier,
**kw0)
VT = VectorTensorProductSpace(T)
VM = MixedTensorProductSpace([T] * (dim + 1))
mask = T.get_mask_nyquist() if params.mask_nyquist else None
kw = {
'padding_factor': 1.5 if params.dealias == '3/2-rule' else 1,
'dealias_direct': params.dealias == '2/3-rule'
}
Vp = [
FunctionSpace(params.N[i],
'F',
domain=(0, params.L[i]),
dtype=dtype(i),
**kw) for i in range(dim)
]
Tp = TensorProductSpace(comm,
Vp,
dtype=float,
slab=(params.decomposition == 'slab'),
collapse_fourier=collapse_fourier,
**kw0)
VTp = VectorTensorProductSpace(Tp)
VMp = MixedTensorProductSpace([Tp] * (dim + 1))
# Mesh variables
X = T.local_mesh(True)
K = T.local_wavenumbers(scaled=True)
for i in range(dim):
X[i] = X[i].astype(float)
K[i] = K[i].astype(float)
K2 = np.zeros(T.shape(True), dtype=float)
for i in range(dim):
K2 += K[i] * K[i]
K_over_K2 = np.zeros(VT.shape(True), dtype=float)
for i in range(dim):
K_over_K2[i] = K[i] / np.where(K2 == 0, 1, K2)
# Solution variables
Ur = Array(VM)
Ur_hat = Function(VM)
P = Array(T)
P_hat = Function(T)
curl = Array(T)
W_hat = Function(T)
ur_dealias = Array(VMp)
# Create views into large data structures
rho = Ur[2]
rho_hat = Ur_hat[2]
U = Ur[:2]
U_hat = Ur_hat[:2]
# Primary variable
u = Ur_hat
# RHS and work arrays
dU = Function(VM)
work = work_arrays()
hdf5file = BqFile(config.params.solver,
checkpoint={
'space': VM,
'data': {
'0': {
'Ur': [Ur_hat]
}
}
},
results={
'space': VM,
'data': {
'UR': [Ur]
}
})
return config.AttributeDict(locals())
def get_context():
"""Set up context for solver"""
# Get points and weights for Chebyshev weighted integrals
assert params.Dquad == params.Bquad
collapse_fourier = False if params.dealias == '3/2-rule' else True
ST = Basis(params.N[0], 'C', bc=(0, 0), quad=params.Dquad)
SB = Basis(params.N[0], 'C', bc='Biharmonic', quad=params.Bquad)
CT = Basis(params.N[0], 'C', quad=params.Dquad)
ST0 = Basis(params.N[0], 'C', bc=(0, 0), quad=params.Dquad) # For 1D problem
K0 = Basis(params.N[1], 'F', domain=(0, params.L[1]), dtype='D')
K1 = Basis(params.N[2], 'F', domain=(0, params.L[2]), dtype='d')
kw0 = {'threads': params.threads,
'planner_effort': params.planner_effort["dct"],
'slab': (params.decomposition == 'slab'),
'collapse_fourier': collapse_fourier}
FST = TensorProductSpace(comm, (ST, K0, K1), **kw0) # Dirichlet
FSB = TensorProductSpace(comm, (SB, K0, K1), **kw0) # Biharmonic
FCT = TensorProductSpace(comm, (CT, K0, K1), **kw0) # Regular Chebyshev
VFS = VectorTensorProductSpace([FSB, FST, FST])
VFST = VectorTensorProductSpace([FST, FST, FST])
VUG = MixedTensorProductSpace([FSB, FST])
VCT = VectorTensorProductSpace(FCT)
mask = FST.get_mask_nyquist() if params.mask_nyquist else None
# Padded
kw = {'padding_factor': 1.5 if params.dealias == '3/2-rule' else 1,
'dealias_direct': params.dealias == '2/3-rule'}
if params.dealias == '3/2-rule':
# Requires new bases due to planning and transforms on different size arrays
STp = Basis(params.N[0], 'C', bc=(0, 0), quad=params.Dquad)
SBp = Basis(params.N[0], 'C', bc='Biharmonic', quad=params.Bquad)
CTp = Basis(params.N[0], 'C', quad=params.Dquad)
else:
STp, SBp, CTp = ST, SB, CT
K0p = Basis(params.N[1], 'F', dtype='D', domain=(0, params.L[1]), **kw)
K1p = Basis(params.N[2], 'F', dtype='d', domain=(0, params.L[2]), **kw)
FSTp = TensorProductSpace(comm, (STp, K0p, K1p), **kw0)
FSBp = TensorProductSpace(comm, (SBp, K0p, K1p), **kw0)
FCTp = TensorProductSpace(comm, (CTp, K0p, K1p), **kw0)
VFSp = VectorTensorProductSpace([FSBp, FSTp, FSTp])
float, complex, mpitype = datatypes("double")
# Mesh variables
X = FST.local_mesh(True)
x0, x1, x2 = FST.mesh()
K = FST.local_wavenumbers(scaled=True)
# Solution variables
U = Array(VFS)
U0 = Array(VFS)
U_hat = Function(VFS)
U_hat0 = Function(VFS)
g = Function(FST)
# primary variable
u = (U_hat, g)
H_hat = Function(VFST)
H_hat0 = Function(VFST)
H_hat1 = Function(VFST)
dU = Function(VFS)
hv = Function(FSB)
hg = Function(FST)
Source = Array(VFS)
Sk = Function(VFS)
K2 = K[1]*K[1]+K[2]*K[2]
K4 = K2**2
K_over_K2 = np.zeros((2,)+g.shape)
for i in range(2):
K_over_K2[i] = K[i+1] / np.where(K2 == 0, 1, K2)
for i in range(3):
K[i] = K[i].astype(float)
work = work_arrays()
u_dealias = Array(VFSp)
u0_hat = np.zeros((2, params.N[0]), dtype=complex)
h0_hat = np.zeros((2, params.N[0]), dtype=complex)
w = np.zeros((params.N[0], ), dtype=complex)
w1 = np.zeros((params.N[0], ), dtype=complex)
nu, dt, N = params.nu, params.dt, params.N
alfa = K2[0] - 2.0/nu/dt
# Collect all matrices
mat = config.AttributeDict(
dict(CDD=inner_product((ST, 0), (ST, 1)),
AB=HelmholtzCoeff(N[0], 1., -(K2 - 2.0/nu/dt), 0, ST.quad),
AC=BiharmonicCoeff(N[0], nu*dt/2., (1. - nu*dt*K2), -(K2 - nu*dt/2.*K4), 0, SB.quad),
# Matrices for biharmonic equation
CBD=inner_product((SB, 0), (ST, 1)),
ABB=inner_product((SB, 0), (SB, 2)),
BBB=inner_product((SB, 0), (SB, 0)),
SBB=inner_product((SB, 0), (SB, 4)),
# Matrices for Helmholtz equation
ADD=inner_product((ST, 0), (ST, 2)),
BDD=inner_product((ST, 0), (ST, 0)),
BBD=inner_product((SB, 0), (ST, 0)),
CDB=inner_product((ST, 0), (SB, 1)),
ADD0=inner_product((ST0, 0), (ST0, 2)),
BDD0=inner_product((ST0, 0), (ST0, 0)),))
la = config.AttributeDict(
dict(HelmholtzSolverG=Helmholtz(mat.ADD, mat.BDD, -np.ones((1, 1, 1)),
(K2+2.0/nu/dt)),
BiharmonicSolverU=Biharmonic(mat.SBB, mat.ABB, mat.BBB, -nu*dt/2.*np.ones((1, 1, 1)),
(1.+nu*dt*K2),
(-(K2 + nu*dt/2.*K4))),
HelmholtzSolverU0=Helmholtz(mat.ADD0, mat.BDD0, np.array([-1.]), np.array([2./nu/dt])),
TDMASolverD=TDMA(inner_product((ST, 0), (ST, 0)))))
hdf5file = KMMFile(config.params.solver,
checkpoint={'space': VFS,
'data': {'0': {'U': [U_hat]},
'1': {'U': [U_hat0]}}},
results={'space': VFS,
'data': {'U': [U]}})
return config.AttributeDict(locals())
def get_context():
"""Set up context for solver"""
# Get points and weights for Chebyshev weighted integrals
assert params.Dquad == params.Bquad
collapse_fourier = False if params.dealias == '3/2-rule' else True
ST = Basis(params.N[0], 'C', bc=(0, 0), quad=params.Dquad)
CT = Basis(params.N[0], 'C', quad=params.Dquad)
CP = Basis(params.N[0], 'C', quad=params.Dquad)
K0 = Basis(params.N[1], 'F', domain=(0, params.L[1]), dtype='D')
K1 = Basis(params.N[2], 'F', domain=(0, params.L[2]), dtype='d')
CP.slice = lambda: slice(0, CT.N)
kw0 = {'threads': params.threads,
'planner_effort': params.planner_effort["dct"],
'slab': (params.decomposition == 'slab'),
'collapse_fourier': collapse_fourier}
FST = TensorProductSpace(comm, (ST, K0, K1), **kw0) # Dirichlet
FCT = TensorProductSpace(comm, (CT, K0, K1), **kw0) # Regular Chebyshev N
FCP = TensorProductSpace(comm, (CP, K0, K1), **kw0) # Regular Chebyshev N-2
VFS = VectorTensorProductSpace(FST)
VCT = VectorTensorProductSpace(FCT)
VQ = MixedTensorProductSpace([VFS, FCP])
mask = FST.get_mask_nyquist() if params.mask_nyquist else None
# Padded
kw = {'padding_factor': 1.5 if params.dealias == '3/2-rule' else 1,
'dealias_direct': params.dealias == '2/3-rule'}
if params.dealias == '3/2-rule':
# Requires new bases due to planning and transforms on different size arrays
STp = Basis(params.N[0], 'C', bc=(0, 0), quad=params.Dquad)
CTp = Basis(params.N[0], 'C', quad=params.Dquad)
else:
STp, CTp = ST, CT
K0p = Basis(params.N[1], 'F', dtype='D', domain=(0, params.L[1]), **kw)
K1p = Basis(params.N[2], 'F', dtype='d', domain=(0, params.L[2]), **kw)
FSTp = TensorProductSpace(comm, (STp, K0p, K1p), **kw0)
FCTp = TensorProductSpace(comm, (CTp, K0p, K1p), **kw0)
VFSp = VectorTensorProductSpace(FSTp)
VCp = MixedTensorProductSpace([FSTp, FCTp, FCTp])
float, complex, mpitype = datatypes("double")
constraints = ((3, 0, 0),
(3, params.N[0]-1, 0))
# Mesh variables
X = FST.local_mesh(True)
x0, x1, x2 = FST.mesh()
K = FST.local_wavenumbers(scaled=True)
# Solution variables
UP_hat = Function(VQ)
UP_hat0 = Function(VQ)
U_hat, P_hat = UP_hat
U_hat0, P_hat0 = UP_hat0
UP = Array(VQ)
UP0 = Array(VQ)
U, P = UP
U0, P0 = UP0
# primary variable
u = UP_hat
H_hat = Function(VFS)
H_hat0 = Function(VFS)
H_hat1 = Function(VFS)
dU = Function(VQ)
Source = Array(VFS) # Note - not using VQ. Only used for constant pressure gradient
Sk = Function(VFS)
K2 = K[1]*K[1]+K[2]*K[2]
for i in range(3):
K[i] = K[i].astype(float)
work = work_arrays()
u_dealias = Array(VFSp)
curl_hat = Function(VCp)
curl_dealias = Array(VCp)
nu, dt, N = params.nu, params.dt, params.N
up = TrialFunction(VQ)
vq = TestFunction(VQ)
ut, pt = up
vt, qt = vq
alfa = 2./nu/dt
a0 = inner(vt, (2./nu/dt)*ut-div(grad(ut)))
a1 = inner(vt, (2./nu)*grad(pt))
a2 = inner(qt, (2./nu)*div(ut))
M = BlockMatrix(a0+a1+a2)
# Collect all matrices
mat = config.AttributeDict(
dict(CDD=inner_product((ST, 0), (ST, 1)),
AB=HelmholtzCoeff(N[0], 1., alfa-K2, 0, ST.quad),))
la = None
hdf5file = CoupledFile(config.params.solver,
checkpoint={'space': VQ,
'data': {'0': {'UP': [UP_hat]},
'1': {'UP': [UP_hat0]}}},
results={'space': VFS,
'data': {'U': [U]}})
return config.AttributeDict(locals())
def get_context():
"""Set up context for solver"""
# Get points and weights for Chebyshev weighted integrals
assert params.Dquad == params.Bquad
ST = Basis(params.N[0], 'C', bc=(0, 0), quad=params.Dquad)
SB = Basis(params.N[0], 'C', bc='Biharmonic', quad=params.Bquad)
CT = Basis(params.N[0], 'C', quad=params.Dquad)
ST0 = Basis(params.N[0], 'C', bc=(0, 0),
quad=params.Dquad) # For 1D problem
K0 = Basis(params.N[1], 'F', domain=(0, params.L[1]), dtype='D')
K1 = Basis(params.N[2], 'F', domain=(0, params.L[2]), dtype='d')
kw0 = {
'threads': params.threads,
'planner_effort': params.planner_effort["dct"]
}
FST = TensorProductSpace(comm, (ST, K0, K1),
axes=(0, 1, 2),
collapse_fourier=False,
**kw0) # Dirichlet
FSB = TensorProductSpace(comm, (SB, K0, K1),
axes=(0, 1, 2),
collapse_fourier=False,
**kw0) # Biharmonic
FCT = TensorProductSpace(comm, (CT, K0, K1),
axes=(0, 1, 2),
collapse_fourier=False,
**kw0) # Regular Chebyshev
VFS = MixedTensorProductSpace([FSB, FST, FST])
VUG = MixedTensorProductSpace([FSB, FST])
# Padded
kw = {
'padding_factor': 1.5 if params.dealias == '3/2-rule' else 1,
'dealias_direct': params.dealias == '2/3-rule'
}
if params.dealias == '3/2-rule':
# Requires new bases due to planning and transforms on different size arrays
STp = Basis(params.N[0], 'C', bc=(0, 0), quad=params.Dquad)
SBp = Basis(params.N[0], 'C', bc='Biharmonic', quad=params.Bquad)
CTp = Basis(params.N[0], 'C', quad=params.Dquad)
else:
STp, SBp, CTp = ST, SB, CT
K0p = Basis(params.N[1], 'F', dtype='D', domain=(0, params.L[1]), **kw)
K1p = Basis(params.N[2], 'F', dtype='d', domain=(0, params.L[2]), **kw)
FSTp = TensorProductSpace(comm, (STp, K0p, K1p),
axes=(0, 1, 2),
collapse_fourier=False,
**kw0)
FSBp = TensorProductSpace(comm, (SBp, K0p, K1p),
axes=(0, 1, 2),
collapse_fourier=False,
**kw0)
FCTp = TensorProductSpace(comm, (CTp, K0p, K1p),
axes=(0, 1, 2),
collapse_fourier=False,
**kw0)
VFSp = MixedTensorProductSpace([FSBp, FSTp, FSTp])
Nu = params.N[0] - 2 # Number of velocity modes in Shen basis
Nb = params.N[0] - 4 # Number of velocity modes in Shen biharmonic basis
u_slice = slice(0, Nu)
v_slice = slice(0, Nb)
float, complex, mpitype = datatypes("double")
# Mesh variables
X = FST.local_mesh(True)
x0, x1, x2 = FST.mesh()
K = FST.local_wavenumbers(scaled=True)
# Solution variables
U = Array(VFS)
U0 = Array(VFS)
U_hat = Function(VFS)
U_hat0 = Function(VFS)
g = Function(FST)
# primary variable
u = (U_hat, g)
H_hat = Function(VFS)
H_hat0 = Function(VFS)
H_hat1 = Function(VFS)
dU = Function(VUG)
hv = Function(FST)
hg = Function(FST)
Source = Array(VFS)
Sk = Function(VFS)
K2 = K[1] * K[1] + K[2] * K[2]
K4 = K2**2
# Set Nyquist frequency to zero on K that is used for odd derivatives in nonlinear terms
Kx = FST.local_wavenumbers(scaled=True, eliminate_highest_freq=True)
K_over_K2 = np.zeros((2, ) + g.shape)
for i in range(2):
K_over_K2[i] = K[i + 1] / np.where(K2 == 0, 1, K2)
work = work_arrays()
nu, dt, N = params.nu, params.dt, params.N
alfa = K2[0] - 2.0 / nu / dt
# Collect all matrices
mat = config.AttributeDict(
dict(
CDD=inner_product((ST, 0), (ST, 1)),
AB=HelmholtzCoeff(N[0], 1.0, -(K2 - 2.0 / nu / dt), ST.quad),
AC=BiharmonicCoeff(N[0],
nu * dt / 2., (1. - nu * dt * K2),
-(K2 - nu * dt / 2. * K4),
quad=SB.quad),
# Matrices for biharmonic equation
CBD=inner_product((SB, 0), (ST, 1)),
ABB=inner_product((SB, 0), (SB, 2)),
BBB=inner_product((SB, 0), (SB, 0)),
SBB=inner_product((SB, 0), (SB, 4)),
# Matrices for Helmholtz equation
ADD=inner_product((ST, 0), (ST, 2)),
BDD=inner_product((ST, 0), (ST, 0)),
BBD=inner_product((SB, 0), (ST, 0)),
CDB=inner_product((ST, 0), (SB, 1)),
ADD0=inner_product((ST0, 0), (ST0, 2)),
BDD0=inner_product((ST0, 0), (ST0, 0)),
))
## Collect all linear algebra solvers
#la = config.AttributeDict(dict(
#HelmholtzSolverG = old_Helmholtz(N[0], np.sqrt(K2[0]+2.0/nu/dt), ST),
#BiharmonicSolverU = old_Biharmonic(N[0], -nu*dt/2., 1.+nu*dt*K2[0],
#-(K2[0] + nu*dt/2.*K4[0]), quad=SB.quad,
#solver="cython"),
#HelmholtzSolverU0 = old_Helmholtz(N[0], np.sqrt(2./nu/dt), ST),
#TDMASolverD = TDMA(inner_product((ST, 0), (ST, 0)))
#)
#)
mat.ADD.axis = 0
mat.BDD.axis = 0
mat.SBB.axis = 0
la = config.AttributeDict(
dict(HelmholtzSolverG=Helmholtz(mat.ADD, mat.BDD, -np.ones(
(1, 1, 1)), (K2[0] + 2.0 / nu / dt)[np.newaxis, :, :]),
BiharmonicSolverU=Biharmonic(
mat.SBB, mat.ABB, mat.BBB, -nu * dt / 2. * np.ones(
(1, 1, 1)), (1. + nu * dt * K2[0])[np.newaxis, :, :],
(-(K2[0] + nu * dt / 2. * K4[0]))[np.newaxis, :, :]),
HelmholtzSolverU0=Helmholtz(mat.ADD0, mat.BDD0, np.array([-1.]),
np.array([2. / nu / dt])),
TDMASolverD=TDMA(inner_product((ST, 0), (ST, 0)))))
hdf5file = KMMWriter({
"U": U[0],
"V": U[1],
"W": U[2]
},
chkpoint={
'current': {
'U': U
},
'previous': {
'U': U0
}
},
filename=params.solver + ".h5",
mesh={
"x": x0,
"y": x1,
"z": x2
})
return config.AttributeDict(locals())
def get_context():
"""Set up context for solver"""
collapse_fourier = False if params.dealias == '3/2-rule' else True
family = 'C'
ST = Basis(params.N[0], family, bc=(0, 0), quad=params.Dquad)
CT = Basis(params.N[0], family, quad=params.Dquad)
CP = Basis(params.N[0], family, quad=params.Dquad)
K0 = Basis(params.N[1], 'F', domain=(0, params.L[1]), dtype='D')
K1 = Basis(params.N[2], 'F', domain=(0, params.L[2]), dtype='d')
#CP.slice = lambda: slice(0, CP.N-2)
constraints = ((3, 0, 0),
(3, params.N[0]-1, 0))
kw0 = {'threads': params.threads,
'planner_effort': params.planner_effort["dct"],
'slab': (params.decomposition == 'slab'),
'collapse_fourier': collapse_fourier}
FST = TensorProductSpace(comm, (ST, K0, K1), **kw0) # Dirichlet
FCT = TensorProductSpace(comm, (CT, K0, K1), **kw0) # Regular Chebyshev N
FCP = TensorProductSpace(comm, (CP, K0, K1), **kw0) # Regular Chebyshev N-2
VFS = VectorTensorProductSpace(FST)
VCT = VectorTensorProductSpace(FCT)
VQ = MixedTensorProductSpace([VFS, FCP])
mask = FST.mask_nyquist() if params.mask_nyquist else None
# Padded
kw = {'padding_factor': 1.5 if params.dealias == '3/2-rule' else 1,
'dealias_direct': params.dealias == '2/3-rule'}
if params.dealias == '3/2-rule':
# Requires new bases due to planning and transforms on different size arrays
STp = Basis(params.N[0], family, bc=(0, 0), quad=params.Dquad)
CTp = Basis(params.N[0], family, quad=params.Dquad)
else:
STp, CTp = ST, CT
K0p = Basis(params.N[1], 'F', dtype='D', domain=(0, params.L[1]), **kw)
K1p = Basis(params.N[2], 'F', dtype='d', domain=(0, params.L[2]), **kw)
FSTp = TensorProductSpace(comm, (STp, K0p, K1p), **kw0)
FCTp = TensorProductSpace(comm, (CTp, K0p, K1p), **kw0)
VFSp = VectorTensorProductSpace(FSTp)
VCp = MixedTensorProductSpace([FSTp, FCTp, FCTp])
float, complex, mpitype = datatypes("double")
# Mesh variables
X = FST.local_mesh(True)
x0, x1, x2 = FST.mesh()
K = FST.local_wavenumbers(scaled=True)
# Solution variables
UP_hat = Function(VQ)
UP_hat0 = Function(VQ)
U_hat, P_hat = UP_hat
U_hat0, P_hat0 = UP_hat0
UP = Array(VQ)
UP0 = Array(VQ)
U, P = UP
U0, P0 = UP0
# RK parameters
a = (8./15., 5./12., 3./4.)
b = (0.0, -17./60., -5./12.)
# primary variable
u = UP_hat
H_hat = Function(VFS)
dU = Function(VQ)
hv = np.zeros((2,)+H_hat.shape, dtype=np.complex)
Source = Array(VFS) # Note - not using VQ. Only used for constant pressure gradient
Sk = Function(VFS)
K2 = K[1]*K[1]+K[2]*K[2]
# Set Nyquist frequency to zero on K that is used for odd derivatives in nonlinear terms
Kx = FST.local_wavenumbers(scaled=True, eliminate_highest_freq=True)
for i in range(3):
K[i] = K[i].astype(float)
Kx[i] = Kx[i].astype(float)
work = work_arrays()
u_dealias = Array(VFSp)
curl_hat = Function(VCp)
curl_dealias = Array(VCp)
nu, dt, N = params.nu, params.dt, params.N
up = TrialFunction(VQ)
vq = TestFunction(VQ)
ut, pt = up
vt, qt = vq
M = []
for rk in range(3):
a0 = inner(vt, (2./nu/dt/(a[rk]+b[rk]))*ut-div(grad(ut)))
a1 = inner(vt, (2./nu/(a[rk]+b[rk]))*grad(pt))
a2 = inner(qt, (2./nu/(a[rk]+b[rk]))*div(ut))
M.append(BlockMatrix(a0+a1+a2))
# Collect all matrices
if ST.family() == 'chebyshev':
mat = config.AttributeDict(
dict(AB=[HelmholtzCoeff(N[0], 1., -(K2 - 2./nu/dt/(a[rk]+b[rk])), 0, ST.quad) for rk in range(3)],))
else:
mat = config.AttributeDict(
dict(ADD=inner_product((ST, 0), (ST, 2)),
BDD=inner_product((ST, 0), (ST, 0)))
)
la = None
hdf5file = CoupledRK3File(config.params.solver,
checkpoint={'space': VQ,
'data': {'0': {'UP': [UP_hat]}}},
results={'space': VFS,
'data': {'U': [U]}})
del rk
return config.AttributeDict(locals())
