Beispiel #1
0
def Divu(U, U_hat, c):
    c[:] = 0
    SFTc.Mult_Div_3D(N[0], K[1, 0], K[2, 0], U_hat[0, u_slice],
                     U_hat[1, u_slice], U_hat[2, u_slice], c[p_slice])
    c[p_slice] = SFTc.TDMA_3D(a0N, b0N, bcN, c0N, c[p_slice])

    return c
Beispiel #2
0
def solvePressure(P_hat, U_hat):
    global F_tmp, F_tmp2
    U_tmp4[:] = 0
    U_tmp3[:] = 0
    F_tmp2[:] = 0
    Ni = F_tmp2

    # dudx = 0 from continuity equation. Use Shen Dirichlet basis
    # Use regular Chebyshev basis for dvdx and dwdx
    F_tmp[0] = Cm.matvec(U_hat[0])
    F_tmp[0, u_slice] = SFTc.TDMA_3D(a0, b0, bc, c0, F_tmp[0, u_slice])
    dudx = U_tmp4[0] = ifst(F_tmp[0], U_tmp4[0], ST)

    SFTc.Mult_DPhidT_3D(N[0], U_hat[1], U_hat[2], F_tmp[1], F_tmp[2])
    dvdx = U_tmp4[1] = ifct(F_tmp[1], U_tmp4[1])
    dwdx = U_tmp4[2] = ifct(F_tmp[2], U_tmp4[2])

    dudy_h = 1j * K[1] * U_hat[0]
    dudy = U_tmp3[0] = ifst(dudy_h, U_tmp3[0], ST)
    dudz_h = 1j * K[2] * U_hat[0]
    dudz = U_tmp3[1] = ifst(dudz_h, U_tmp3[1], ST)
    Ni[0] = fst(U0[0] * dudx + U0[1] * dudy + U0[2] * dudz, Ni[0], ST)

    U_tmp3[:] = 0
    dvdy_h = 1j * K[1] * U_hat[1]
    dvdy = U_tmp3[0] = ifst(dvdy_h, U_tmp3[0], ST)
    dvdz_h = 1j * K[2] * U_hat[1]
    dvdz = U_tmp3[1] = ifst(dvdz_h, U_tmp3[1], ST)
    Ni[1] = fst(U0[0] * dvdx + U0[1] * dvdy + U0[2] * dvdz, Ni[1], ST)

    U_tmp3[:] = 0
    dwdy_h = 1j * K[1] * U_hat[2]
    dwdy = U_tmp3[0] = ifst(dwdy_h, U_tmp3[0], ST)
    dwdz_h = 1j * K[2] * U_hat[2]
    dwdz = U_tmp3[1] = ifst(dwdz_h, U_tmp3[1], ST)
    Ni[2] = fst(U0[0] * dwdx + U0[1] * dwdy + U0[2] * dwdz, Ni[2], ST)

    F_tmp[0] = 0
    SFTc.Mult_Div_3D(N[0], K[1, 0], K[2, 0], Ni[0, u_slice], Ni[1, u_slice],
                     Ni[2, u_slice], F_tmp[0, p_slice])
    SFTc.Solve_Helmholtz_3D_complex(N[0], 1, F_tmp[0, p_slice], P_hat[p_slice],
                                    u0N, u1N, u2N, LN)

    return P_hat
Beispiel #3
0
def pressurerhs(U_hat, dU):
    dU[:] = 0.
    SFTc.Mult_Div_3D(N[0], K[1, 0], K[2, 0], U_hat[0, u_slice],
                     U_hat[1, u_slice], U_hat[2, u_slice], dU[p_slice])
    dU[p_slice] *= -1. / dt
    return dU