focal (2) problem.2rheolef.gz

NAME

       problem - linear solver (rheolef-7.1)

DESCRIPTION

       The problem class solves a given linear system for PDEs in variational formulation.

DESCRIPTION

       The degrees of freedom are splitting between unknown degrees of freedom and blocked one. See also form(2)
       and space(2). Let a be a bilinear form(2) and lh be the right-hand-side, as in the previous example. The
       linear system expands as:

           [ a.uu  a.ub ] [ uh.u ]   [ lh.u ]
           [            ] [      ] = [      ]
           [ a.bu  a.bb ] [ uh.b ]   [ lh.b ]

       The uh.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 =  lh.u - a.ub*uh.b

       This writes:

           problem p (a);
           p.solve (lh, uh);

       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. When using an iterative resolution, the details about
       its convergence, e.g. the number of iterations and the final residue, can be obtain via the p.option()
       member function, see solver_option(4). Finally, the previous linear system is solved via the solver(4)
       class: the problem class is simply a convenient wrapper around the solver(4) one.

EXAMPLE

       See dirichlet.cc

CUSTOMIZATION

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

           problem p (a, sopt);

       When using a direct solver(4), the determinant of the linear system matrix is also available as p.det().
       When using an iterative solver(4), the preconditionner could be customized:

           p.set_preconditionner (m);

TODO

       The solve method could return a boolean when success.

IMPLEMENTATION

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

       The problem class is simply an alias to the problem_basic class

       typedef problem_basic<Float> problem;

       The problem_basic class provides a generic interface:

       template <class T, class M = rheo_default_memory_model>
       class problem_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_basic ();
         problem_basic (const form_basic<T,M>& a,
                        const solver_option& sopt = solver_option());

         void update_value (const form_basic<T,M>& a);

         void set_preconditioner (const solver_basic<T,M>&);

       // accessor:

         void solve       (const field_basic<T,M>& lh, field_basic<T,M>& uh) const;
         void trans_solve (const field_basic<T,M>& lh, field_basic<T,M>& uh) const;

         determinant_type det() const;
         const solver_option& option() const;
         bool initialized() const;

       };

AUTHOR

       Pierre  Saramito  <Pierre.Saramito@imag.fr>

COPYRIGHT

       Copyright   (C)  2000-2018  Pierre  Saramito  <Pierre.Saramito@imag.fr> GPLv3+: GNU GPL version 3 or
       later  <http://gnu.org/licenses/gpl.html>.  This  is  free  software:  you  are free to change and
       redistribute it.  There is NO WARRANTY, to the extent permitted by law.