def main(solver): h = 0.125 end_time = 1 num_steps = 5 time_step = end_time / num_steps # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e2, "kf_n": 1e2, "mass_weight": 1.0 / time_step, # inverse of the time step "num_steps": num_steps, "L": 1, # l-scheme constant "L_p": 1e3, # inner l-scheme for iterative solver "beta": 1, # non-linearity constant "r": 2.3, } # solve with MoLDD xor ItLDD scheme num_iter = common.solve_(solver, h, param, PowerLaw) print(num_iter)
def test_mesh_size(solver): end_time = 1 num_steps = 5 time_step = end_time / num_steps # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e2, "kf_n": 1e2, "mass_weight": 1.0 / time_step, # inverse of the time step "num_steps": num_steps, "L": 1, # l-scheme constant "L_p": 1e3, # inner l-scheme for iterative solver "beta": 1, "r": 2.3, } # loop over the mesh sizes mesh_sizes = np.array([0.5, 0.125, 0.03125]) num_iter = np.empty((mesh_sizes.size, num_steps)) for idx, mesh_size in enumerate(mesh_sizes): # solve with MoLDD xor ItLDD scheme num_iter[idx, :] = common.solve_(solver, mesh_size, param, PowerLaw) np.savetxt("powerlaw_mesh_size_" + solver + ".txt", num_iter, fmt="%d", delimiter=",")
def test_L(solver): mesh_size = 0.125 end_time = 1 num_steps = 5 time_step = end_time / num_steps # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e2, "kf_n": 1e2, "mass_weight": 1.0 / time_step, # inverse of the time step "num_steps": num_steps, "L_p": 1e3, # inner l-scheme for iterative solver "beta": 1, "r": 2.3, } Ls = 0.025 * np.arange(101) num_iter_L = np.empty((Ls.size, num_steps), dtype=np.int) for idx, L in enumerate(Ls): param["L"] = L # solve with MoLDD xor ItLDD scheme num_iter_L[idx, :] = common.solve_(solver, mesh_size, param, PowerLaw) np.savetxt("powerlaw_L_dependency_" + solver + ".txt", num_iter_L, fmt="%d", delimiter=",")
def test_mortar(solver): mesh_size = 0.125 / 4 end_time = 1 num_steps = 5 time_step = end_time / num_steps # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e-2, "kf_n": 1e-2, "mass_weight": 1.0 / time_step, # inverse of the time step "num_steps": num_steps, "L": 1, "L_p": 200, # inner l-scheme for iterative solver "beta": 1, } mortar_sizes = np.array([0.25, 0.5, 1, 2, 4]) num_iter_mortar_size = np.empty((mortar_sizes.size, num_steps), dtype=np.int) for idx, mortar_size in enumerate(mortar_sizes): param["mortar_size"] = mortar_size # solve with MoLDD xor ItLDD scheme num_iter_mortar_size[idx, :] = common.solve_(solver, mesh_size, param, Forchheimer) np.savetxt("forchheimer_mortar_size_dependency_" + solver + ".txt", num_iter_mortar_size, fmt="%d", delimiter=",")
def test_alpha(solver): mesh_size = 0.125 end_time = 1 num_steps = 5 time_step = end_time / num_steps # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e2, "mass_weight": 1.0 / time_step, # inverse of the time step "num_steps": num_steps, "L": 1, "L_p": 1e3, # inner l-scheme for iterative solver "beta": 1, } alphas = np.array([1e0, 1e1, 1e2, 1e3]) num_iter_alpha = np.empty((alphas.size, num_steps), dtype=np.int) for idx, alpha in enumerate(alphas): param["kf_n"] = alpha # solve with MoLDD xor ItLDD scheme num_iter_alpha[idx, :] = common.solve_(solver, mesh_size, param, Forchheimer) np.savetxt("forchheimer_alpha_dependency_" + solver + ".txt", num_iter_alpha, fmt="%d", delimiter=",")
def test_L_Lp(solver): mesh_size = 0.125 end_time = 1 num_steps = 5 time_step = end_time / num_steps # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e2, "kf_n": 1e2, "mass_weight": 1.0 / time_step, # inverse of the time step "num_steps": num_steps, "omega": 1, "zeta": 1, # non-linearity constant "r": 1.5, } Ls = np.linspace(0, 2) # 50 points (including endpoint) Lps = np.power(10, np.arange(2.2, 4.3, 0.1)) # 20 points (up to 4.2) num_iter_L = [np.empty((Ls.size, Lps.size), dtype=np.int)] * num_steps for row, L in enumerate(Ls): param["L"] = L for col, Lp in enumerate(Lps): param["L_p"] = Lp # solve with MoLDD xor ItLDD scheme iters = common.solve_(solver, mesh_size, param, Cross) for t in range(num_steps): num_iter_L[t][row, col] = iters[t] for t in range(num_steps): np.savetxt("cross_L_Lp_" + solver + "_" + str(t + 1) + ".txt", num_iter_L[t], fmt="%d", delimiter=",")
def test_parameters(solver): mesh_size = 0.125 end_time = 1 num_steps = 5 time_step = end_time / num_steps # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e2, "kf_n": 1e2, "mass_weight": 1.0 / time_step, # inverse of the time step "num_steps": num_steps, "L": 1, # l-scheme constant "L_p": 1e3, # inner l-scheme for iterative solver } # change the value of beta betas = np.array([1e-1, 1., 10.]) param["r"] = 2.3 num_iter_beta = np.empty((betas.size, num_steps), dtype=np.int) for idx, beta in enumerate(betas): # consider the parameters param["beta"] = beta # solve with MoLDD xor ItLDD scheme num_iter_beta[idx, :] = common.solve_(solver, mesh_size, param, PowerLaw) np.savetxt("powerlaw_beta_dependency_" + solver + ".txt", num_iter_beta, fmt="%d", delimiter=",") """
def test_time_step(solver): mesh_size = 0.125 end_time = 1 # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e2, "kf_n": 1e2, "L": 1, # l-scheme constant "L_p": 1e3, # inner l-scheme for iterative solver "omega": 1, "zeta": 1, # non-linearity constant "r": 1.5, } # loop over the time steps num_steps = np.array([4, 8, 16]) num_iter = np.zeros((num_steps.size, np.amax(num_steps)), dtype=np.int) for idx, num_step in enumerate(num_steps): time_step = end_time / num_step # consider the extra parameters param["mass_weight"] = 1.0 / time_step param["num_steps"] = num_step # solve with MoLDD xor ItLDD scheme num_iter[idx, :num_step] = common.solve_(solver, mesh_size, param, Cross) np.savetxt("cross_time_step_" + solver + ".txt", num_iter, fmt="%d", delimiter=",")
def test_parameters(solver): mesh_size = 0.125 end_time = 1 num_steps = 5 time_step = end_time / num_steps # the flow problem param = { "tol": 1e-6, "k": 1, "aperture": 1e-2, "kf_t": 1e2, "kf_n": 1e2, "mass_weight": 1.0 / time_step, # inverse of the time step "num_steps": num_steps, "L": 1, # l-scheme constant "L_p": 1e3, # inner l-scheme for iterative solver } # change the value of omega omegas = np.array([1e-1, 1., 2.5]) param["zeta"] = 1 param["r"] = 1.5 num_iter_omega = np.empty((omegas.size, num_steps), dtype=np.int) for idx, omega in enumerate(omegas): # consider the parameters param["omega"] = omega # solve with MoLDD xor ItLDD scheme num_iter_omega[idx, :] = common.solve_(solver, mesh_size, param, Cross) np.savetxt("cross_omega_dependency_" + solver + ".txt", num_iter_omega, fmt="%d", delimiter=",") # change the value of zeta zetas = np.array([1., 10., 1e2]) param["omega"] = 1 param["r"] = 1.5 num_iter_zeta = np.empty((zetas.size, num_steps), dtype=np.int) for idx, zeta in enumerate(zetas): # consider the parameters param["zeta"] = zeta # solve with MoLDD xor ItLDD scheme num_iter_zeta[idx, :] = common.solve_(solver, mesh_size, param, Cross) np.savetxt("cross_zeta_dependency_" + solver + ".txt", num_iter_zeta, fmt="%d", delimiter=",") # change the value of r rs = np.array([1., 1.5, 4.5]) param["omega"] = 1 param["zeta"] = 1 num_iter_r = np.empty((rs.size, num_steps), dtype=np.int) for idx, r in enumerate(rs): # consider the parameters param["r"] = r # solve with MoLDD xor ItLDD scheme num_iter_r[idx, :] = common.solve_(solver, mesh_size, param, Cross) np.savetxt("cross_r_dependency_" + solver + ".txt", num_iter_r, fmt="%d", delimiter=",")