def uJacobi(rho):
global U
global L, N
temp_sol = np.zeros_like(rho)
jCnt = 0
while True:
temp_sol[1:L, 2:N] = ((grid.hz2*(U[0:L-1, 2:N] + U[2:L+1, 2:N])*grid.xix2Coll[:, npax] +
grid.hx2*(U[1:L, 1:N-1] + U[1:L, 3:N+1])*grid.ztz2Stag[1:-1])*
gv.dt/(grid.hz2hx2*2.0*gv.Re) + rho[1:L, 2:N]) / \
(1.0 + gv.dt*(grid.hz2*grid.xix2Coll[:, npax] + grid.hx2*grid.ztz2Stag[1:-1])/(gv.Re*grid.hz2hx2))
# SWAP ARRAYS AND IMPOSE BOUNDARY CONDITION
U, temp_sol = temp_sol, U
U = bc.imposeUBCs(U)
maxErr = np.amax(
np.fabs(rho[1:L, 2:N] -
(U[1:L, 2:N] - 0.5 * gv.dt *
((U[0:L - 1, 2:N] - 2.0 * U[1:L, 2:N] + U[2:L + 1, 2:N]) *
grid.xix2Coll[:, npax] / grid.hx2 +
(U[1:L, 1:N - 1] - 2.0 * U[1:L, 2:N] + U[1:L, 3:N + 1]) *
grid.ztz2Stag[1:-1] / grid.hz2) / gv.Re)))
if maxErr < gv.tolerance:
break
jCnt += 1
if jCnt > grid.maxCount:
print("ERROR: Jacobi not converging in U. Aborting")
print("Maximum error: ", maxErr)
quit()
def euler():
global N, L
global U, W, P
global Hx, Hz, Pp
Hx.fill(0.0)
Hz.fill(0.0)
computeNLinDiff_X(U, W)
computeNLinDiff_Z(U, W)
# Add constant pressure gradient forcing for channel flows
if gv.probType == 1:
Hx[:, :] += 1.0
# Calculating guessed values of U implicitly
Hx[1:L, 1:N +
1] = U[1:L, 1:N +
1] + gv.dt * (Hx[1:L, 1:N + 1] - grid.xi_xColl[:, npax] *
(P[2:L + 1, 1:N + 1] - P[1:L, 1:N + 1]) / grid.hx)
uJacobi(Hx)
# Calculating guessed values of W implicitly
Hz[1:L + 1, 1:N] = W[1:L + 1, 1:N] + gv.dt * (
Hz[1:L + 1, 1:N] - grid.zt_zColl[:] *
(P[1:L + 1, 2:N + 1] - P[1:L + 1, 1:N]) / grid.hz)
wJacobi(Hz)
# Calculating pressure correction term
rhs = np.zeros([L + 2, N + 2])
rhs[1:L + 1, 1:N + 1] = ((U[1:L + 1, 1:N + 1] - U[0:L, 1:N + 1]) *
grid.xi_xStag[:, npax] / grid.hx +
(W[1:L + 1, 1:N + 1] - W[1:L + 1, 0:N]) *
grid.zt_zStag[:] / grid.hz) / gv.dt
ps.multigrid(Pp, rhs)
# Add pressure correction.
P = P + Pp
# Update new values for U and W
U[1:L, 1:N +
1] = U[1:L, 1:N + 1] - gv.dt * (Pp[2:L + 1, 1:N + 1] - Pp[1:L, 1:N + 1]
) * grid.xi_xColl[:, npax] / grid.hx
W[1:L + 1, 1:N] = W[1:L + 1, 1:N] - gv.dt * (
Pp[1:L + 1, 2:N + 1] - Pp[1:L + 1, 1:N]) * grid.zt_zColl[:] / grid.hz
# Impose no-slip BC on new values of U and W
U = bc.imposeUBCs(U)
W = bc.imposeWBCs(W)
print(U[30, 30], W[30, 30])
def euler():
global N, M, L
global U, V, W, P
global Hx, Hy, Hz, Pp
Hx.fill(0.0)
Hy.fill(0.0)
Hz.fill(0.0)
computeNLinDiff_X(U, V, W)
computeNLinDiff_Y(U, V, W)
computeNLinDiff_Z(U, V, W)
# Add constant pressure gradient forcing for channel flows
if gv.probType == 1:
Hx[:, :, :] += 1.0
# Calculating guessed values of U implicitly
Hx[1:L, 1:M + 1, 1:N + 1] = U[1:L, 1:M + 1, 1:N + 1] + gv.dt * (
Hx[1:L, 1:M + 1, 1:N + 1] -
(P[2:L + 1, 1:M + 1, 1:N + 1] - P[1:L, 1:M + 1, 1:N + 1]) / grid.hx)
uJacobi(Hx)
# Calculating guessed values of V implicitly
Hy[1:L + 1, 1:M, 1:N + 1] = V[1:L + 1, 1:M, 1:N + 1] + gv.dt * (
Hy[1:L + 1, 1:M, 1:N + 1] -
(P[1:L + 1, 2:M + 1, 1:N + 1] - P[1:L + 1, 1:M, 1:N + 1]) / grid.hy)
vJacobi(Hy)
# Calculating guessed values of W implicitly
Hz[1:L + 1, 1:M + 1, 1:N] = W[1:L + 1, 1:M + 1, 1:N] + gv.dt * (
Hz[1:L + 1, 1:M + 1, 1:N] -
(P[1:L + 1, 1:M + 1, 2:N + 1] - P[1:L + 1, 1:M + 1, 1:N]) / grid.hz)
wJacobi(Hz)
# Calculating pressure correction term
rhs = np.zeros([L + 2, M + 2, N + 2])
rhs[1:L + 1, 1:M + 1, 1:N + 1] = (
(U[1:L + 1, 1:M + 1, 1:N + 1] - U[0:L, 1:M + 1, 1:N + 1]) / grid.hx +
(V[1:L + 1, 1:M + 1, 1:N + 1] - V[1:L + 1, 0:M, 1:N + 1]) / grid.hy +
(W[1:L + 1, 1:M + 1, 1:N + 1] - W[1:L + 1, 1:M + 1, 0:N]) /
grid.hz) / gv.dt
if gv.solveMethod[0:2] == 'MG':
ps.multigrid(Pp, rhs)
# Add pressure correction.
P = P + Pp
# Update new values for U, V and W
U[1:L, 1:M + 1, 1:N + 1] = U[1:L, 1:M + 1, 1:N + 1] - gv.dt * (
Pp[2:L + 1, 1:M + 1, 1:N + 1] - Pp[1:L, 1:M + 1, 1:N + 1]) / grid.hx
V[1:L + 1, 1:M, 1:N + 1] = V[1:L + 1, 1:M, 1:N + 1] - gv.dt * (
Pp[1:L + 1, 2:M + 1, 1:N + 1] - Pp[1:L + 1, 1:M, 1:N + 1]) / grid.hy
W[1:L + 1, 1:M + 1, 1:N] = W[1:L + 1, 1:M + 1, 1:N] - gv.dt * (
Pp[1:L + 1, 1:M + 1, 2:N + 1] - Pp[1:L + 1, 1:M + 1, 1:N]) / grid.hz
# Impose no-slip BC on new values of U, V and W
U = bc.imposeUBCs(U)
V = bc.imposeVBCs(V)
W = bc.imposeWBCs(W)
print(U[30, 30, 30], V[30, 30, 30], W[30, 30, 30])