Rheolef  7.2
an efficient C++ finite element environment
problem

linear solver

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 and space. Let a be a bilinear form 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. Finally, the previous linear system is solved via the solver class: the problem class is simply a convenient wrapper around the solver one.

Example

See dirichlet.cc

Customization

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

    problem p (a, sopt);

When using a direct solver, the determinant of the linear system matrix is also available as p.det(). When using an iterative solver, 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;
problem_basic< Float > problem
Definition: problem.h:163

The problem_basic class provides a generic interface:

template <class T, class M = rheo_default_memory_model>
class problem_basic {
public:
// typedefs:
// allocators:
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;
const solver_option& option() const;
bool initialized() const;
field lh(Float epsilon, Float t, const test &v)
void set_preconditioner(const solver_basic< T, M > &)
Definition: problem.h:196
void solve(const field_basic< T, M > &lh, field_basic< T, M > &uh) const
Definition: problem.h:203
void update_value(const form_basic< T, M > &a)
Definition: problem.h:188
solver_basic< T, M >::determinant_type determinant_type
Definition: problem.h:126
solver_basic< T, M >::size_type size_type
Definition: problem.h:125
void trans_solve(const field_basic< T, M > &lh, field_basic< T, M > &uh) const
Definition: problem.h:209
const solver_option & option() const
Definition: problem.h:230
determinant_type det() const
Definition: problem.h:223
bool initialized() const
Definition: problem.h:216
rep::determinant_type determinant_type
Definition: solver.h:271
rep::size_type size_type
Definition: solver.h:270
};