Esempio n. 1
0
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)
Esempio n. 2
0
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=",")
Esempio n. 3
0
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=",")
Esempio n. 4
0
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=",")
Esempio n. 5
0
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=",")
Esempio n. 6
0
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=",")
Esempio n. 7
0
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=",")
    """
Esempio n. 8
0
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=",")
Esempio n. 9
0
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=",")