# 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

### Whiteboard

Just writing down a related idea:

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):
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.

No subscribers.