---
name: "problem"
section: "2rheolef"
platform: "linux"
package: "librheolef-dev"
version: "7.2-4"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/problem"
---

# problem(2rheolef)

linear solver (rheolef-7.2)

## NAME

problem - linear solver (rheolef-7.2)

## 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.**