`problem_mixed`

linear solver

# Description

The `problem_mixed` class solves a given linear mixed system for PDEs in variational formulation.

Mixed problem appear in many applications such as the Stokes or the nearly incompressible elasticity. Let `Xh` and `Qh` be two finite element `space`. Let `a: Xh*Xh --> IR`, `b: Xh*Qh --> IR` and `c: Xh*Qh --> IR` be three bilinear `form`. The system writes:

        [ A  B^T ] [ uh ]   [ lh ]
        [        ] [    ] = [    ]
        [ B  -C  ] [ ph ]   [ kh ]

where `A`, `B` and `C` are the three operators associated to `a`, `b` and `c`, respectively, and `lh in Xh` and `kh in Qh` are the two given right-hand-sides. The `c` bilinear form is called the stabilization, and could be zero.

The degrees of freedom are split between unknown degrees of freedom and blocked one. See also `form` and `space`. The linear system expands as:

        [ a.uu  a.ub   b.uu^T b.bu^T ] [ uh.u ]   [ lh.u ]
        [                            ] [      ] = [      ]
        [ a.bu  a.bb   b.ub^T b.bb^T ] [ uh.b ]   [ lh.b ]
        [                            ] [      ] = [      ]
        [ b.uu  b.ub  -c.uu  -c.ub   ] [ ph.u ]   [ kh.u ]
        [                            ] [      ] = [      ]
        [ b.bu  a.bb  -c.bu  -c.bb   ] [ ph.b ]   [ kh.b ]

Both the `uh.b` and `ph.b` are blocked degrees of freedom: their values are prescribed and the corresponding values are move to the right-hand-side of the system that reduces to:

        a.uu*uh.u + b.uu^T*ph.u = lh.u - a.ub*uh.b - b.bu^T*ph.b

        b.uu*uh.u -   c.uu*ph.u = kh.u - b.ub*uh.b +   c.ub*ph.b

This writes:

        problem_mixed p (a, b, c);
        p.solve (lh, kh, uh, ph);

When `c` is zero, the last `c` argument could be omitted, as:

        problem_mixed p (a, b);

Observe that, during the `p.solve` call, `uh` is both an input variable, for the `uh.b` contribution to the right-hand-side, and an output variable, with `uh.u`. This is also true for `ph` when `ph.b` is non-empty. The previous linear system is solved via the `solver_abtb` class: the `problem_mixed` class is simply a convenient wrapper around the `solver_abtb` one.

# Example

See stokes_cavity.cc

# Options

The `solver_abtb` could be customized via the constructor optional `solver_option` argument:

        problem p (a, b, sopt);

or

        problem p (a, b, c, sopt);

This `solver_abtb` is used to switch between a direct and an iterative method for solving the mixed system.

# Metric

A metric in the `Qh` space could also be provided:

        p.set_metric (mp);

By default, when nothing has been specified, this metric is the L2 scalar product for the `Qh` space.

When using a direct `solver` method, this metric is used to add a constraint when the multiplier is known up to a constant. For instance, when the pressure is known up to a constant, a constraint for a zero average pressure is automatically added to the linear system.

When using an iterative `solver` method, this metric is used as a Schur complement preconditionner, see `solver_abtb` for details. The `solver` associated to this Schur preconditionner could be customized by specifying the `solver` associated to the `problem` related to the `mp` operator:

    p.set_preconditionner (pmp);

Note this preconditionner subproblem could be solved either by a direct or an iterative method, while the whole mixed problem solver is iterative.

# Inner solver

When using an iterative `solver_abtb`, the inner `problem` related to the `a` operator could also be customized by specifying its `solver` :

        p.set_inner_problem (pa);

Note this inner subproblem could be solved either by a direct or an iterative method, while the whole mixed problem solver is iterative.

# Implementation

This documentation has been generated from file main/lib/problem_mixed.h

The `problem_mixed` class is simply an alias to the `problem_mixed_basic` class

typedef problem_mixed_basic<Float> problem_mixed;

The `problem_mixed_basic` class provides a generic interface:

template <class T, class M = rheo_default_memory_model>
class problem_mixed_basic {
public:
// typedefs:
typedef typename solver_basic<T,M>::size_type size_type;
typedef typename solver_basic<T,M>::determinant_type determinant_type;
// allocators:
problem_mixed_basic();
problem_mixed_basic(
const form_basic<T,M>& a,
const form_basic<T,M>& b,
const solver_option& sopt = solver_option());
problem_mixed_basic(
const form_basic<T,M>& a,
const form_basic<T,M>& b,
const form_basic<T,M>& c,
const solver_option& sopt = solver_option());
// accessor:
void solve (const field_basic<T,M>& lh, const field_basic<T,M>& kh,
field_basic<T,M>& uh, field_basic<T,M>& ph) const;
bool initialized() const;
const solver_option& option() const;
// modifiers:
void set_metric (const form& mp);
void set_preconditionner (const problem& pmp);
void set_inner_problem (const problem& pa);
};
rheolef::problem_mixed_basic::solve
void solve(const field_basic< T, M > &lh, const field_basic< T, M > &kh, field_basic< T, M > &uh, field_basic< T, M > &ph) const
Definition: problem_mixed.h:351
form
see the form page for the full documentation
rheolef::problem_mixed
problem_mixed_basic< Float > problem_mixed
see the problem_mixed page for the full documentation
Definition: problem_mixed.h:236
rheolef::problem_mixed_basic::set_inner_problem
void set_inner_problem(const problem &pa)
Definition: problem_mixed.h:322
rheolef::solver_basic::size_type
rep::size_type size_type
Definition: solver.h:270
rheolef::solver_basic::determinant_type
rep::determinant_type determinant_type
Definition: solver.h:271
rheolef::problem_mixed_basic::set_preconditionner
void set_preconditionner(const problem &pmp)
Definition: problem_mixed.h:315
mkgeo_ball.c
c
Definition: mkgeo_ball.sh:153
rheolef::problem_mixed_basic::determinant_type
solver_basic< T, M >::determinant_type determinant_type
Definition: problem_mixed.h:184
rheolef::problem_mixed_basic::problem_mixed_basic
problem_mixed_basic()
Definition: problem_mixed.h:244
rheolef::problem_mixed_basic::option
const solver_option & option() const
Definition: problem_mixed.h:301
rheolef::problem_mixed_basic::set_metric
void set_metric(const form &mp)
Definition: problem_mixed.h:308
rheolef::problem_mixed_basic::size_type
solver_basic< T, M >::size_type size_type
Definition: problem_mixed.h:183
a
Definition: diffusion_isotropic.h:25
lh
field lh(Float epsilon, Float t, const test &v)
Definition: burgers_diffusion_operators.icc:25
problem
see the problem page for the full documentation
rheolef::problem_mixed_basic::initialized
bool initialized() const
Definition: problem_mixed.h:294
mkgeo_ball.b
b
Definition: mkgeo_ball.sh:152