dolfin team mailing list archive

[Johan Jansson <johanjan@xxxxxxxxxxxxxxxx>]

On Thu, Jul 22, 2004 at 04:32:58PM -0400, Bing Jian wrote:
> Hi,
>     I'm looking for a solver for systems of linear elliptic PDEs,
> To be specific, if you happen to have Trottenberg's Multigrid book
> on hand, could you please turn to page 290?
>     My system to be solved is a linear elliptic 2*2 system of
> PDEs in 2 dimensions, or maybe 3*3 system in 3 dimensions, depending
> on the real problem. However, here I just assume 2*2 system in 2D
> case.
>    If I write the system in
>                  Lu = f
>    then
>      L is a 2*2 matrix of differential operators, with diagonal
> elements have second order diff operators (also with first and
> zero order terms) and non-diagonal elements only have first and
> zero order terms. All the coefficients are also functions of
> (x,y) with know numerical values. I am not math guy and just
> reading some books on numerical PDEs, hope my description
> is clear.
>     I saw from the website of DOLFIN that solvers to systems of PDEs
> have been recently added into the DOLFIN, I am wondering if
> my problem can be solved by DOLFIN. I am familar with C++ programming,
> so there is possibility, I can try to figure out the details.
>     Many thanks in advance!
> 

Hi Bing,

Your problem should definitely be solvable in DOLFIN. I'm not familiar
with the book you're referring to, but your description of the problem
is clear.

DOLFIN expects the problem to be input in variational form (or weak
form), so you would have to multiply the equation by a test function v
= (v_1, v_2) and integrate on both sides. For the terms with second
order derivatives, you have to move one of the derivatives to the test
function (due to the elements being linear).

You can look at the stationary elasticity module or the vector wave
module for some examples (the stationary elasticity equation isn't
time dependent, so it should be very similar to the one you're
describing).

The left hand side of the scalar wave equation (with backward Euler
time discretization) looks like this in the DOLFIN module (from
Wave.h):

      return (1 / k * u * v + k * (grad(u), grad(v))) * dx;

You can use a ddx() notation as well for individual derivatives
(gradients are expanded):

      return (1 / k * u * v + k * (ddx(u) * ddx(v) + ddy(u) + ddy(v)) * dx;

while the left hand side of the vector wave equation looks like this
(from WaveVector.h):

      return
        (1 / k * u(0) * v(0) + k *
         (ddx(u(0)) * ddx(v(0)) + ddy(u(0)) * ddy(v(0)))) * dx +
        (1 / k * u(1) * v(1) + k *
         (ddx(u(1)) * ddx(v(1)) + ddy(u(1)) * ddy(v(1)))) * dx;

(Note: I changed u.ddx() to ddx(u) for clarity, both are allowed, but
the latter probably preferred.)

Hope this helps,
  Johan