def test_only_first_order(V):
    u = Coefficient(V)

    v = TestFunction(V)

    c = Coefficient(V)

    F = (inner(c, c) * inner(Dt(Dt(u)), v) + inner(grad(u), grad(v)) +
         inner(c, v) + inner(Dt(u), v)) * dx

    with pytest.raises(ValueError):
        check_integrals(F.integrals(), expect_time_derivative=True)
def wave(n, deg, butcher_tableau, splitting=AI):
    N = 2**n
    msh = UnitIntervalMesh(N)

    params = {
        "snes_type": "ksponly",
        "ksp_type": "preonly",
        "mat_type": "aij",
        "pc_type": "lu"
    }

    V = FunctionSpace(msh, "CG", deg)
    W = FunctionSpace(msh, "DG", deg - 1)
    Z = V * W

    x, = SpatialCoordinate(msh)

    t = Constant(0.0)
    dt = Constant(2.0 / N)

    up = project(as_vector([0, sin(pi * x)]), Z)
    u, p = split(up)

    v, w = TestFunctions(Z)

    F = (inner(Dt(u), v) * dx + inner(u.dx(0), w) * dx + inner(Dt(p), w) * dx -
         inner(p, v.dx(0)) * dx)

    E = 0.5 * (inner(u, u) * dx + inner(p, p) * dx)

    stepper = TimeStepper(F,
                          butcher_tableau,
                          t,
                          dt,
                          up,
                          solver_parameters=params,
                          splitting=splitting)

    energies = []

    while (float(t) < 1.0):
        if (float(t) + float(dt) > 1.0):
            dt.assign(1.0 - float(t))
        stepper.advance()
        t.assign(float(t) + float(dt))
        energies.append(assemble(E))

    return np.array(energies)
def heat_subdomainbc(N, deg, butcher_tableau, splitting=AI):
    dt = Constant(1.0 / N)
    t = Constant(0.0)

    msh = UnitSquareMesh(N, N)

    V = FunctionSpace(msh, "CG", 2)
    x, y = SpatialCoordinate(msh)

    uexact = t*(x+y)
    rhs = expand_derivatives(diff(uexact, t)) - div(grad(uexact))

    u = interpolate(uexact, V)

    v = TestFunction(V)
    n = FacetNormal(msh)
    F = inner(Dt(u), v)*dx + inner(grad(u), grad(v))*dx - inner(rhs, v)*dx - inner(dot(grad(uexact), n), v)*ds

    bc = DirichletBC(V, uexact, [1, 2])

    luparams = {"mat_type": "aij",
                "snes_type": "ksponly",
                "ksp_type": "preonly",
                "pc_type": "lu"}

    stepper = TimeStepper(F, butcher_tableau, t, dt, u, bcs=bc,
                          solver_parameters=luparams)

    while (float(t) < 1.0):
        if (float(t) + float(dt) > 1.0):
            dt.assign(1.0 - float(t))
        stepper.advance()
        t.assign(float(t) + float(dt))

    return norm(u-uexact)
示例#4
0
def StokesTest(N, butcher_tableau, stage_type="deriv", splitting=AI):
    mesh = UnitSquareMesh(N, N)

    Ve = VectorElement("CG", mesh.ufl_cell(), 2)
    Pe = FiniteElement("CG", mesh.ufl_cell(), 1)
    Ze = MixedElement([Ve, Pe])
    Z = FunctionSpace(mesh, Ze)

    t = Constant(0.0)
    dt = Constant(1.0/N)
    (x, y) = SpatialCoordinate(mesh)

    uexact = as_vector([x*t + y**2, -y*t+t*(x**2)])
    pexact = Constant(0, domain=mesh)

    u_rhs = expand_derivatives(diff(uexact, t)) - div(grad(uexact)) + grad(pexact)
    p_rhs = -div(uexact)

    z = Function(Z)
    test_z = TestFunction(Z)
    (u, p) = split(z)
    (v, q) = split(test_z)
    F = (inner(Dt(u), v)*dx
         + inner(grad(u), grad(v))*dx
         - inner(p, div(v))*dx
         - inner(q, div(u))*dx
         - inner(u_rhs, v)*dx
         - inner(p_rhs, q)*dx)

    bcs = [DirichletBC(Z.sub(0), uexact, "on_boundary")]
    nsp = [(1, VectorSpaceBasis(constant=True))]

    u, p = z.split()
    u.interpolate(uexact)

    lu = {"mat_type": "aij",
          "snes_type": "newtonls",
          "snes_linesearch_type": "l2",
          "snes_linesearch_monitor": None,
          "snes_monitor": None,
          "snes_rtol": 1e-8,
          "snes_atol": 1e-8,
          "snes_force_iteration": 1,
          "ksp_type": "preonly",
          "pc_type": "lu",
          "pc_factor_mat_solver_type": "mumps"}

    stepper = TimeStepper(F, butcher_tableau, t, dt, z,
                          stage_type=stage_type,
                          bcs=bcs, solver_parameters=lu, nullspace=nsp)

    while (float(t) < 1.0):
        if (float(t) + float(dt) > 1.0):
            dt.assign(1.0 - float(t))
        stepper.advance()
        t.assign(float(t) + float(dt))

    (u, p) = z.split()
    return errornorm(uexact, u) + errornorm(pexact, p)
def test_can_split_mixed(W):
    u = Coefficient(W)

    v = TestFunction(W)

    c = Coefficient(W)

    F = (inner(c, c) * inner(Dt(u), v) + inner(grad(u), grad(v)) +
         inner(c, v) + inner(Dt(u), v)) * dx

    split = extract_terms(F)

    expect_t = (inner(c, c) * inner(Dt(u), v) + inner(Dt(u), v)) * dx
    expect_no_t = inner(grad(u), grad(v)) * dx + inner(c, v) * dx

    assert sig(expect_t) == sig(split.time)
    assert sig(expect_no_t) == sig(split.remainder)
示例#6
0
def Fubc(V, uexact, rhs):
    u = interpolate(uexact, V)
    v = TestFunction(V)
    F = inner(Dt(u), v) * dx + inner(grad(u), grad(v)) * dx - inner(rhs,
                                                                    v) * dx

    bc = DirichletBC(V, uexact, "on_boundary")

    return (F, u, bc)
示例#7
0
def NSETest(butch, stage_type, splitting):
    N = 16
    M = UnitSquareMesh(N, N)

    V = VectorFunctionSpace(M, "CG", 2)
    W = FunctionSpace(M, "CG", 1)
    Z = V * W

    up = Function(Z)
    u, p = split(up)
    v, q = TestFunctions(Z)

    Re = Constant(100.0)

    F = (inner(Dt(u), v) * dx
         + 1.0 / Re * inner(grad(u), grad(v)) * dx
         + inner(dot(grad(u), u), v) * dx
         - p * div(v) * dx
         + div(u) * q * dx
         )

    bcs = [DirichletBC(Z.sub(0), Constant((1, 0)), (4,)),
           DirichletBC(Z.sub(0), Constant((0, 0)), (1, 2, 3))]

    nullspace = [(1, VectorSpaceBasis(constant=True))]

    solver_parameters = {"mat_type": "aij",
                         "snes_type": "newtonls",
                         "snes_linesearch_type": "bt",
                         "snes_linesearch_monitor": None,
                         "snes_monitor": None,
                         "snes_rtol": 1e-10,
                         "snes_atol": 1e-10,
                         "snes_force_iteration": 1,
                         "ksp_type": "preonly",
                         "pc_type": "lu",
                         "pc_factor_mat_solver_type": "mumps"}

    t = Constant(0.0)
    dt = Constant(0.3/N)
    stepper = TimeStepper(F, butch,
                          t, dt, up,
                          bcs=bcs,
                          stage_type="value",
                          solver_parameters=solver_parameters,
                          nullspace=nullspace)

    tfinal = 1.0
    while (float(t) < tfinal):
        if (float(t) + float(dt) > tfinal):
            dt.assign(1.0 - float(t))
        stepper.advance()
        t.assign(float(t) + float(dt))
    u, p = up.split()
    return norm(u)
def test_can_split_mixed_split(W):
    u = Coefficient(W)
    from ufl import split as splt
    u0, u1 = splt(u)

    v = TestFunction(W)
    v0, v1 = splt(v)

    c = Coefficient(W)

    F = (inner(c, c) * inner(Dt(u0), v0) + inner(grad(u), grad(v)) +
         inner(c, v) + inner(Dt(u), v)) * dx

    split = extract_terms(F)

    expect_t = (inner(c, c) * inner(Dt(u0), v0) + inner(Dt(u), v)) * dx
    expect_no_t = inner(grad(u), grad(v)) * dx + inner(c, v) * dx

    assert sig(expect_t) == sig(split.time)
    assert sig(expect_no_t) == sig(split.remainder)
示例#9
0
def test_1d_heat_dirichletbc(butcher_tableau):

    # Boundary values
    u_0 = Constant(2.0)
    u_1 = Constant(3.0)

    N = 100
    x0 = 0.0
    x1 = 10.0
    msh = IntervalMesh(N, x1)
    V = FunctionSpace(msh, "CG", 1)
    dt = Constant(10.0 / N)
    t = Constant(0.0)
    (x,) = SpatialCoordinate(msh)

    # Method of manufactured solutions copied from Heat equation demo.
    S = Constant(2.0)
    C = Constant(1000.0)
    B = (x - Constant(x0)) * (x - Constant(x1)) / C
    R = (x * x) ** 0.5
    # Note end linear contribution
    uexact = (
        B * atan(t) * (pi / 2.0 - atan(S * (R - t)))
        + u_0
        + ((x - x0) / x1) * (u_1 - u_0)
    )
    rhs = expand_derivatives(diff(uexact, t)) - div(grad(uexact))
    u = interpolate(uexact, V)
    v = TestFunction(V)
    F = (
        inner(Dt(u), v) * dx
        + inner(grad(u), grad(v)) * dx
        - inner(rhs, v) * dx
    )
    bc = [
        DirichletBC(V, u_1, 2),
        DirichletBC(V, u_0, 1),
    ]

    luparams = {"mat_type": "aij", "ksp_type": "preonly", "pc_type": "lu"}
    stepper = TimeStepper(
        F, butcher_tableau, t, dt, u, bcs=bc, solver_parameters=luparams
    )

    t_end = 2.0
    while float(t) < t_end:
        if float(t) + float(dt) > t_end:
            dt.assign(t_end - float(t))
        stepper.advance()
        t.assign(float(t) + float(dt))
        # Check solution and boundary values
        assert norm(u - uexact) / norm(uexact) < 10.0 ** -5
        assert isclose(u.at(x0), u_0)
        assert isclose(u.at(x1), u_1)
示例#10
0
def test_appctx():
    msh = UnitIntervalMesh(2)
    V = FunctionSpace(msh, "CG", 1)
    u = Function(V)
    v = TestFunction(V)

    F = inner(Dt(u) + u, v) * dx

    bt = GaussLegendre(1)
    t = Constant(0.0)
    dt = Constant(0.1)

    stepper = TimeStepper(F, bt, t, dt, u, appctx={"hello": "world"})
    assert "hello" in stepper.solver._ctx.appctx
示例#11
0
def heat(n, deg, time_stages, stage_type="deriv", splitting=IA):
    N = 2**n
    msh = UnitIntervalMesh(N)

    params = {
        "snes_type": "ksponly",
        "ksp_type": "preonly",
        "mat_type": "aij",
        "pc_type": "lu"
    }

    V = FunctionSpace(msh, "CG", deg)
    x, = SpatialCoordinate(msh)

    t = Constant(0.0)
    dt = Constant(2.0 / N)

    uexact = exp(-t) * sin(pi * x)
    rhs = expand_derivatives(diff(uexact, t)) - div(grad(uexact))

    butcher_tableau = GaussLegendre(time_stages)

    u = project(uexact, V)

    v = TestFunction(V)

    F = (inner(Dt(u), v) * dx + inner(grad(u), grad(v)) * dx -
         inner(rhs, v) * dx)

    bc = DirichletBC(V, Constant(0), "on_boundary")

    stepper = TimeStepper(F,
                          butcher_tableau,
                          t,
                          dt,
                          u,
                          bcs=bc,
                          solver_parameters=params,
                          stage_type=stage_type,
                          splitting=splitting)

    while (float(t) < 1.0):
        if (float(t) + float(dt) > 1.0):
            dt.assign(1.0 - float(t))
        stepper.advance()
        t.assign(float(t) + float(dt))

    return errornorm(uexact, u) / norm(uexact)
def test_expecting_time_derivative(V):
    u = Coefficient(V)

    v = TestFunction(V)

    c = Coefficient(V)

    F = (inner(grad(u), grad(v)) + inner(c, v)) * dx

    with pytest.raises(ValueError):
        check_integrals(F.integrals(), expect_time_derivative=True)

    check_integrals(F.integrals(), expect_time_derivative=False)

    F += inner(Dt(u), v) * dx
    with pytest.raises(ValueError):
        check_integrals(F.integrals(), expect_time_derivative=False)
示例#13
0
def RTCFtest(N, deg, butcher_tableau, splitting=AI):

    msh = UnitSquareMesh(N, N, quadrilateral=True)

    Ve = FiniteElement("RTCF", msh.ufl_cell(), 2)
    V = FunctionSpace(msh, Ve)

    dt = Constant(0.1 / N)
    t = Constant(0.0)

    x, y = SpatialCoordinate(msh)

    uexact = as_vector(
        [t + 2 * t * x + 4 * t * y, 7 * t + 5 * t * x + 6 * t * y])
    rhs = expand_derivatives(diff(uexact, t)) + grad(div(uexact))

    u = project(uexact, V)

    v = TestFunction(V)
    F = inner(Dt(u), v) * dx + inner(div(u), div(v)) * dx - inner(rhs, v) * dx
    bc = DirichletBC(V, uexact, "on_boundary")

    luparams = {"mat_type": "aij", "ksp_type": "preonly", "pc_type": "lu"}

    stepper = TimeStepper(F,
                          butcher_tableau,
                          t,
                          dt,
                          u,
                          bcs=bc,
                          solver_parameters=luparams,
                          splitting=splitting)

    while (float(t) < 0.1):
        if (float(t) + float(dt) > 0.1):
            dt.assign(0.1 - float(t))
        stepper.advance()
        print(float(t))
        t.assign(float(t) + float(dt))

    return norm(u - uexact)
示例#14
0
def curltest(N, deg, butcher_tableau, splitting):

    msh = UnitSquareMesh(N, N)

    Ve = FiniteElement("N1curl", msh.ufl_cell(), 2, variant="integral")
    V = FunctionSpace(msh, Ve)

    dt = Constant(0.1 / N)
    t = Constant(0.0)

    x, y = SpatialCoordinate(msh)

    uexact = as_vector([t + 2*t*x + 4*t*y + 3*t*(y**2) + 2*t*x*y, 7*t + 5*t*x + 6*t*y - 3*t*x*y - 2*t*(x**2)])
    rhs = expand_derivatives(diff(uexact, t)) + curl(curl(uexact))

    u = interpolate(uexact, V)

    v = TestFunction(V)
    n = FacetNormal(msh)
    F = inner(Dt(u), v)*dx + inner(curl(u), curl(v))*dx - inner(curlcross(uexact, n), v)*ds - inner(rhs, v)*dx
    bc = DirichletBC(V, uexact, [1, 2])

    luparams = {"mat_type": "aij",
                "ksp_type": "preonly",
                "pc_type": "lu"}

    stepper = TimeStepper(F, butcher_tableau, t, dt, u, bcs=bc,
                          solver_parameters=luparams,
                          splitting=splitting)

    while (float(t) < 0.1):
        if (float(t) + float(dt) > 0.1):
            dt.assign(0.1 - float(t))
        stepper.advance()
        print(float(t))
        t.assign(float(t) + float(dt))

    return norm(u-uexact)
def test_Dt_linear(V, typ):
    u = Coefficient(V)

    v = TestFunction(V)

    c = Coefficient(V)

    F = (inner(grad(u), grad(v)) + inner(c, v) + inner(Dt(u), v)) * dx

    if typ == "mul":
        F += inner(Dt(u), c) * inner(Dt(u), v) * dx
    elif typ == "div":
        F += inner(Dt(u), v) / Dt(u)[0] * dx
    elif typ == "sin":
        F += inner(sin(Dt(u)[0]), v[0]) * dx

    with pytest.raises(ValueError):
        check_integrals(F.integrals(), expect_time_derivative=True)
示例#16
0
u, p = split(up)

n = FacetNormal(msh)

dt = Constant(1.0 / 1600)
t = Constant(0.0)
nu = Constant(0.001)
rho = 1.0
r = 0.05
Umean = 1.0
L = 0.1

# define the variational form once outside the loop
gamma = Constant(1.e2)
F = (
    inner(Dt(u), v) * dx + inner(dot(grad(u), u), v) * dx
    #+ gamma * inner(cell_avg(div(u)), cell_avg(div(v))) * dx
    + nu * inner(grad(u), grad(v)) * dx - inner(p, div(v)) * dx +
    inner(div(u), w) * dx)

# boundary conditions are specified for each subspace
UU = 1.5 * sin(pi * t / 8)
bcs = [
    DirichletBC(Z.sub(0), as_vector([4 * UU * y * (y1 - y) / (y1**2), 0]),
                (4, )),
    DirichletBC(Z.sub(0), Constant((0, 0)), (1, 3, 5))
]

#nullspace = MixedVectorSpaceBasis(
#    Z, [Z.sub(0), VectorSpaceBasis(constant=True)])
示例#17
0
def elastodynamics(N, deg, butcher_tableau, splitting=AI):
    dt = Constant(1.0 / N)
    t = Constant(0.0)

    msh = UnitSquareMesh(N, N)
    x, y = SpatialCoordinate(msh)

    V = VectorFunctionSpace(msh, "CG", 1)
    VV = V * V

    uu1 = Function(VV)
    u1, udot1 = uu1.split()
    u1.interpolate(
        as_vector([sin(pi * x) * sin(pi * y),
                   sin(pi * x) * sin(pi * y)]))

    uu2 = Function(VV)
    u2, udot2 = uu2.split()
    u2.interpolate(
        as_vector([sin(pi * x) * sin(pi * y),
                   sin(pi * x) * sin(pi * y)]))

    u1, udot1 = split(uu1)
    u2, udot2 = split(uu2)

    v, w = TestFunctions(VV)

    F1 = (inner(Dt(u1) - udot1, v) * dx + inner(Dt(udot1), w) * dx +
          inner(grad(u1), grad(w)) * dx)

    F2 = (inner(Dt(u2) - udot2, v) * dx + inner(Dt(udot2), w) * dx +
          inner(grad(u2), grad(w)) * dx)

    bc1 = DirichletBC(VV.sub(0), Function(VV.sub(0)), "on_boundary")
    bc2 = [
        DirichletBC(
            VV.sub(0).sub(i), Function(VV.sub(0).sub(i)), "on_boundary")
        for i in (0, 1)
    ]

    luparams = {
        "mat_type": "aij",
        "snes_type": "ksponly",
        "ksp_type": "preonly",
        "pc_type": "lu"
    }

    stepper1 = TimeStepper(F1,
                           butcher_tableau,
                           t,
                           dt,
                           uu1,
                           bcs=bc1,
                           solver_parameters=luparams,
                           splitting=splitting)

    stepper2 = TimeStepper(F2,
                           butcher_tableau,
                           t,
                           dt,
                           uu2,
                           bcs=bc2,
                           solver_parameters=luparams,
                           splitting=splitting)

    stepper1.advance()
    stepper2.advance()
    return norm(uu1 - uu2)
示例#18
0
# This will give the exact solution at any time t.  We just have
# to t.assign(time_we_want)
uexact = exp(-t) * cos(pi * x) * sin(pi * y)

# MMS works on symbolic differentiation of true solution, not weak form
rhs = expand_derivatives(diff(uexact, t)) - div(grad(uexact))

u = interpolate(uexact, V)

# define the variational form once outside the loop
h = CellSize(msh)
n = FacetNormal(msh)
beta = Constant(100.0)
v = TestFunction(V)
F = (inner(Dt(u), v) * dx + inner(grad(u), grad(v)) * dx - inner(rhs, v) * dx -
     inner(dot(grad(u), n), v) * ds - inner(dot(grad(v), n), u - uexact) * ds +
     beta / h * inner(u - uexact, v) * ds)

params = {
    "mat_type": "aij",
    "snes_type": "ksponly",
    "ksp_type": "preonly",
    "pc_type": "lu"
}

stepper = TimeStepper(F, ButcherTableau, t, dt, u, solver_parameters=params)

while (float(t) < 1.0):
    if (float(t) + float(dt) > 1.0):
        dt.assign(1.0 - float(t))