Approaches for time-dependent problems
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
- Started by
- Completed by
- Martin Sandve Alnæs
Whiteboard
Just writing down a related idea:
pde = Dt(u)*v - dot(grad(u), grad(v)) - f*v
time_discretize
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.
