Provided by: librheolef-dev_7.2-2_amd64 #### NAME

```       problem_mixed - linear solver (rheolef-7.2)

```

#### 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(2). Let a: Xh*Xh --> IR, b: Xh*Qh
--> IR and c: Xh*Qh --> IR be three bilinear form(2). 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(2) and space(2). 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(4)
class: the problem_mixed class is simply a convenient wrapper around the solver_abtb(4)
one.

```

#### EXAMPLE

```       See stokes_cavity.cc

```

#### OPTIONS

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

problem p (a, b, sopt);

or

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

This solver_abtb(4) 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(4) 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(4) method, this metric is used as a Schur complement
preconditionner, see solver_abtb(4) for details. The solver(4) associated to this Schur
preconditionner could be customized by specifying the solver(4) associated to the
problem(2) 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.

```

#### INNERSOLVER

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

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);

};

```

#### AUTHOR

```       Pierre  Saramito  <Pierre.Saramito@imag.fr>

```

```       Copyright   (C)  2000-2018  Pierre  Saramito  <Pierre.Saramito@imag.fr> GPLv3+: GNU GPL