Provided by: librheolef-dev_7.2-2_amd64 bug


       problem_mixed - linear solver (rheolef-7.2)


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

       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   b.ub^T^T ] [ uh.b ]   [ lh.b ]
           [                            ] [      ] = [      ]
           [ b.uu  b.ub  -c.uu  -c.ub   ] [ ph.u ]   [ kh.u ]
           [                            ] [      ] = [      ]
           [ b.bu  -c.bu   ] [ 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)




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

           problem p (a, b, sopt);


           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.


       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

       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.


       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.


       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 {

       // typedefs:

         typedef typename solver_basic<T,M>::size_type         size_type;
         typedef typename solver_basic<T,M>::determinant_type  determinant_type;

       // allocators:


             const form_basic<T,M>& a,
             const form_basic<T,M>& b,
             const solver_option& sopt = solver_option());

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



       Pierre  Saramito  <>


       Copyright   (C)  2000-2018  Pierre  Saramito  <> GPLv3+: GNU GPL
       version 3 or later  <>.  This  is  free  software:  you
       are free to change and redistribute it.  There is NO WARRANTY, to the extent permitted by