UFL

Approaches for time-dependent problems

Registered by Garth Wells

Time derivatives, automatic ODE methods, space-time elements

    - Do we want something like Dt(u), Dtt(u), CR(a), FE(a), BE(a), TR(a, theta)?
    - In particular, this can be interesting in combination with time elements?
        es = FiniteElement("CG", triangle, 1)
        et = TimeElement(1) # Any point in non-Galerkin elements?
        e = es*et
        v = TestFunction(e)
        u = TrialFunction(e)
        f = Function(es)
        g = Function(e)
        a = f*u*v*dx
      Need to extend ufc::cell for this, perhaps adding time interval [t0,t1] as part
      of ufc::cell, new shapes time_triangle etc and bool is_time_dependent() to form.

Blueprint information

Status:
Complete
Approver:
None
Priority:
Medium
Drafter:
None
Direction:
Needs approval
Assignee:
None
Definition:
Obsolete
Series goal:
None
Implementation:
Unknown
Milestone target:
None
Completed by
Martin Sandve Aln├Žs

Related branches

Whiteboard

Just writing down a related idea:

pde = Dt(u)*v - dot(grad(u), grad(v)) - f*v
time_discretized_pde = theta_rule(pde, theta, dt, u, { u: u_prev, f: f_prev })

Here u_prev and f_prev are Coefficients representing f and u at the previous timestep.
And theta and dt are either Coefficients (Constants) or literal floats.
If theta is set to literal 0 or 1, the form will reduce to BE or FE schemes with no penalty.
The system can then be split into lhs, rhs as usual.

I believe this could be implemented if we can split a pde into parts based on time derivatives (dr/dt - w = 0), similar to how we split a pde into parts with lhs, rhs.

--------

An alternative way to represent this idea is to introduce a TimeStepped expression type:
    u = TimeStepped(u_next, u_curr)
    f = TimeStepped(f_next, f_curr)
together with an abstract time derivative type Dt(expr):
    F = (Dt(u)*v + kappa*dot(grad(u), grad(v)) - f*v)*dx
and then the theta rule becomes simply:
    Fth = theta_rule(F, timestep, theta)
with fixed theta=1,0 versions:
    Ffe = forward_euler(F, timestep)
    Fbe = backward_euler(F, timestep)
In the time discretized forms Fth, Ffe, Fbe, the TimeStepped types can either be replaced with the underlying _next, _curr objects, or there could be yet another operator AtTime(u, step) where step is an integer, to retain the information about the time abstraction for analysis.

But a question then is, what will derivative w.r.t. u mean?
v = TestFunction(V)
u_curr = Coefficient(V)
u_next = Coefficient(V)
u = TimeStepped(u_next, u_curr)

Possibly just:
w1 = derivative(u**2*dx, u_next, v) # 2*u_next*v*dx
w2 = derivative(u**2*dx, u_curr, v) # 2*u_prev*v*dx
w3 = derivative(u**2*dx, u, v) # 2*u*v*dx
but the behaviour together with theta_rule should be investigated before this design is finalized.

(?)

Work Items

This blueprint contains Public information 
Everyone can see this information.

Subscribers

No subscribers.