def assemble(self):
N = self.N
SB = Basis(N, 'C', bc='Biharmonic', quad=self.quad)
SB.plan((N, N), 0, np.float, {})
# (u'', v)
K = inner_product((SB, 0), (SB, 2))
# ((1-x**2)u, v)
x = sp.symbols('x', real=True)
K1 = inner_product((SB, 0), (SB, 0), measure=(1-x**2))
# ((1-x**2)u'', v)
K2 = inner_product((SB, 0), (SB, 2), measure=(1-x**2))
# (u'''', v)
Q = inner_product((SB, 0), (SB, 4))
# (u, v)
M = inner_product((SB, 0), (SB, 0))
Re = self.Re
a = self.alfa
B = -Re*a*1j*(K-a**2*M)
A = Q-2*a**2*K+a**4*M - 2*a*Re*1j*M - 1j*a*Re*(K2-a**2*K1)
return A.diags().toarray(), B.diags().toarray()
def assemble(self):
N = self.N
SB = Basis(N, 'C', bc='Biharmonic', quad=self.quad)
SB.plan((N, N), 0, np.float, {})
x, _ = self.x, self.w = SB.points_and_weights(N)
# Trial function
P4 = SB.evaluate_basis_all(x=x)
# Second derivatives
T2x = SB.evaluate_basis_derivative_all(x=x, k=2)
# (u'', v)
K = np.zeros((N, N))
K[:-4, :-4] = inner_product((SB, 0), (SB, 2)).diags().toarray()
# ((1-x**2)u, v)
xx = np.broadcast_to((1 - x**2)[:, np.newaxis], (N, N))
#K1 = np.dot(w*P4.T, xx*P4) # Alternative: K1 = np.dot(w*P4.T, ((1-x**2)*P4.T).T)
K1 = np.zeros((N, N))
K1 = SB.scalar_product(xx * P4, K1)
K1 = extract_diagonal_matrix(
K1).diags().toarray() # For improved roundoff
# ((1-x**2)u'', v)
K2 = np.zeros((N, N))
K2 = SB.scalar_product(xx * T2x, K2)
K2 = extract_diagonal_matrix(
K2).diags().toarray() # For improved roundoff
# (u'''', v)
Q = np.zeros((self.N, self.N))
Q[:-4, :-4] = inner_product((SB, 0), (SB, 4)).diags().toarray()
# (u, v)
M = np.zeros((self.N, self.N))
M[:-4, :-4] = inner_product((SB, 0), (SB, 0)).diags().toarray()
Re = self.Re
a = self.alfa
B = -Re * a * 1j * (K - a**2 * M)
A = Q - 2 * a**2 * K + a**4 * M - 2 * a * Re * 1j * M - 1j * a * Re * (
K2 - a**2 * K1)
return A, B
def assemble(self):
N = self.N
SB = Basis(N, 'C', bc='Biharmonic', quad=self.quad)
SB.plan((N, N), 0, np.float, {})
x, _ = self.x, self.w = SB.points_and_weights(N)
# Trial function
P4 = SB.evaluate_basis_all(x=x)
# Second derivatives
T2x = SB.evaluate_basis_derivative_all(x=x, k=2)
# (u'', v)
K = np.zeros((N, N))
K[:-4, :-4] = inner_product((SB, 0), (SB, 2)).diags().toarray()
# ((1-x**2)u, v)
xx = np.broadcast_to((1-x**2)[:, np.newaxis], (N, N))
#K1 = np.dot(w*P4.T, xx*P4) # Alternative: K1 = np.dot(w*P4.T, ((1-x**2)*P4.T).T)
K1 = np.zeros((N, N))
K1 = SB.scalar_product(xx*P4, K1)
K1 = extract_diagonal_matrix(K1).diags().toarray() # For improved roundoff
# ((1-x**2)u'', v)
K2 = np.zeros((N, N))
K2 = SB.scalar_product(xx*T2x, K2)
K2 = extract_diagonal_matrix(K2).diags().toarray() # For improved roundoff
# (u'''', v)
Q = np.zeros((self.N, self.N))
Q[:-4, :-4] = inner_product((SB, 0), (SB, 4)).diags().toarray()
# (u, v)
M = np.zeros((self.N, self.N))
M[:-4, :-4] = inner_product((SB, 0), (SB, 0)).diags().toarray()
Re = self.Re
a = self.alfa
B = -Re*a*1j*(K-a**2*M)
A = Q-2*a**2*K+a**4*M - 2*a*Re*1j*M - 1j*a*Re*(K2-a**2*K1)
return A, B
def get_context():
"""Set up context for solver"""
# Get points and weights for Chebyshev weighted integrals
ST = Basis(params.N[0], 'C', bc=(0, 0), quad=params.Dquad)
SB = Basis(params.N[0], 'C', bc='Biharmonic', quad=params.Bquad)
ST0 = Basis(params.N[0], 'C', bc=(0, 0),
quad=params.Dquad) # For 1D problem
CT = ST.CT # Chebyshev transform
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)
FST = SlabShen_R2C(params.N,
params.L,
comm,
threads=params.threads,
communication=params.communication,
planner_effort=params.planner_effort,
dealias_cheb=params.dealias_cheb)
float, complex, mpitype = datatypes("double")
ST.plan(FST.complex_shape(), 0, complex, {
'threads': params.threads,
'planner_effort': params.planner_effort["dct"]
})
SB.plan(FST.complex_shape(), 0, complex, {
'threads': params.threads,
'planner_effort': params.planner_effort["dct"]
})
# Mesh variables
X = FST.get_local_mesh(ST)
x0, x1, x2 = FST.get_mesh_dims(ST)
K = FST.get_local_wavenumbermesh(scaled=True)
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
Kx = FST.get_local_wavenumbermesh(scaled=True, eliminate_highest_freq=True)
K_over_K2 = zeros((2, ) + FST.complex_shape())
for i in range(2):
K_over_K2[i] = K[i + 1] / np.where(K2 == 0, 1, K2)
# Solution variables
U = zeros((3, ) + FST.real_shape(), dtype=float)
U0 = zeros((3, ) + FST.real_shape(), dtype=float)
U_hat = zeros((3, ) + FST.complex_shape(), dtype=complex)
U_hat0 = zeros((3, ) + FST.complex_shape(), dtype=complex)
g = zeros(FST.complex_shape(), dtype=complex)
# primary variable
u = (U_hat, g)
H_hat = zeros((3, ) + FST.complex_shape(), dtype=complex)
H_hat0 = zeros((3, ) + FST.complex_shape(), dtype=complex)
H_hat1 = zeros((3, ) + FST.complex_shape(), dtype=complex)
dU = zeros((3, ) + FST.complex_shape(), dtype=complex)
hv = zeros(FST.complex_shape(), dtype=complex)
hg = zeros(FST.complex_shape(), dtype=complex)
Source = zeros((3, ) + FST.real_shape(), dtype=float)
Sk = zeros((3, ) + FST.complex_shape(), dtype=complex)
work = work_arrays()
nu, dt, N = params.nu, params.dt, params.N
kx = K[0][:, 0, 0]
alfa = K2 - 2.0 / nu / dt
# Collect all matrices
mat = config.AttributeDict(
dict(
CDD=inner_product((ST, 0), (ST, 1)),
AB=HelmholtzCoeff(N[0], 1.0, -alfa, ST.quad),
AC=BiharmonicCoeff(N[0],
nu * dt / 2., (1. - nu * dt * K2[0]),
-(K2[0] - nu * dt / 2. * K4[0]),
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))))
mat.ADD.axis = 0
mat.BDD.axis = 0
mat.SBB.axis = 0
# Collect all linear algebra solvers
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 = 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())