My Project
Loading...
Searching...
No Matches
Dune::MultithreadDILU< M, X, Y > Class Template Reference

The OpenMP thread parallelized DILU preconditioner. More...

#include <DILU.hpp>

Inheritance diagram for Dune::MultithreadDILU< M, X, Y >:
Dune::PreconditionerWithUpdate< X, Y >

Public Types

using matrix_type = M
 The matrix type the preconditioner is for.
 
using domain_type = X
 The domain type of the preconditioner.
 
using range_type = Y
 The range type of the preconditioner.
 
using field_type = typename X::field_type
 The field type of the preconditioner.
 

Public Member Functions

 MultithreadDILU (const M &A)
 scalar type underlying the field_type
 
void update () override
 Update the preconditioner.
 
void pre (X &v, Y &d) override
 Prepare the preconditioner.
 
void apply (X &v, const Y &d) override
 Apply the preconditioner.
 
void post (X &x) override
 Clean up.
 
std::vector< typename M::block_type > getDiagonal ()
 
virtual SolverCategory::Category category () const override
 Category of the preconditioner (see SolverCategory::Category)
 
virtual bool hasPerfectUpdate () const override
 
- Public Member Functions inherited from Dune::PreconditionerWithUpdate< X, Y >

Detailed Description

template<class M, class X, class Y>
class Dune::MultithreadDILU< M, X, Y >

The OpenMP thread parallelized DILU preconditioner.

Safe to run serially without OpenMP. When run in parallel the matrix is assumed to be symmetric.

Template Parameters
MThe matrix type to operate on
XType of the update
YType of the defect

Constructor & Destructor Documentation

◆ MultithreadDILU()

template<class M , class X , class Y >
Dune::MultithreadDILU< M, X, Y >::MultithreadDILU ( const M & A)
inline

scalar type underlying the field_type

Constructor gets all parameters to operate the prec.

Parameters
AThe matrix to operate on.

Assuming symmetric matrices using a lower triangular coloring to construct the levels is sufficient

Member Function Documentation

◆ apply()

template<class M , class X , class Y >
void Dune::MultithreadDILU< M, X, Y >::apply ( X & v,
const Y & d )
inlineoverride

Apply the preconditioner.

◆ hasPerfectUpdate()

template<class M , class X , class Y >
virtual bool Dune::MultithreadDILU< M, X, Y >::hasPerfectUpdate ( ) const
inlineoverridevirtual

◆ post()

template<class M , class X , class Y >
void Dune::MultithreadDILU< M, X, Y >::post ( X & x)
inlineoverride

Clean up.

◆ pre()

template<class M , class X , class Y >
void Dune::MultithreadDILU< M, X, Y >::pre ( X & v,
Y & d )
inlineoverride

Prepare the preconditioner.

◆ update()

template<class M , class X , class Y >
void Dune::MultithreadDILU< M, X, Y >::update ( )
inlineoverridevirtual

Update the preconditioner.

Implements Dune::PreconditionerWithUpdate< X, Y >.


The documentation for this class was generated from the following files: