TNL::Solvers Namespace Reference

Namespace for solvers. More...

Namespaces
namespace	Linear
	Namespace for linear system solvers.
namespace	ODE
	Namespace for solvers of ordinary differential equations.

Classes
struct	ConfigTagDevice
struct	ConfigTagExplicitSolver
struct	ConfigTagIndex
struct	ConfigTagIndex< FastBuildConfigTag, long int >
struct	ConfigTagIndex< FastBuildConfigTag, short int >
struct	ConfigTagMeshResolve
struct	ConfigTagReal
struct	ConfigTagReal< FastBuildConfigTag, float >
struct	ConfigTagReal< FastBuildConfigTag, long double >
struct	ConfigTagTimeDiscretisation
struct	ConfigTagTimeDiscretisation< FastBuildConfigTag, ExplicitTimeDiscretisationTag >
struct	ConfigTagTimeDiscretisation< FastBuildConfigTag, ImplicitTimeDiscretisationTag >
struct	ConfigTagTimeDiscretisation< FastBuildConfigTag, SemiImplicitTimeDiscretisationTag >
class	DefaultBuildConfigTag
class	DirectSolver
	Base class for direct solvers. More...
class	ExplicitEulerSolverTag
class	ExplicitMersonSolverTag
class	ExplicitTimeDiscretisationTag
class	FastBuildConfigTag
class	GinkgoConvergenceLoggerMonitor
	A Ginkgo Convergence logger with a TNL iterative solver monitor. More...
class	ImplicitTimeDiscretisationTag
class	IterativeSolver
	Base class for iterative solvers. More...
class	IterativeSolverMonitor
	Object for monitoring convergence of iterative solvers. More...
class	SemiImplicitTimeDiscretisationTag
struct	Solver
struct	SolverConfig
class	SolverInitiator
class	SolverInitiatorDeviceResolver
class	SolverInitiatorDeviceResolver< ProblemSetter, Real, Device, ConfigTag, false >
class	SolverInitiatorDeviceResolver< ProblemSetter, Real, Device, ConfigTag, true >
class	SolverInitiatorIndexResolver
class	SolverInitiatorIndexResolver< ProblemSetter, Real, Device, Index, ConfigTag, false >
class	SolverInitiatorIndexResolver< ProblemSetter, Real, Device, Index, ConfigTag, true >
class	SolverInitiatorMeshResolver
class	SolverInitiatorMeshResolver< ProblemSetter, Real, Device, Index, ConfigTag, false >
class	SolverInitiatorMeshResolver< ProblemSetter, Real, Device, Index, ConfigTag, true >
class	SolverInitiatorRealResolver
class	SolverInitiatorRealResolver< ProblemSetter, Real, ConfigTag, false >
class	SolverInitiatorRealResolver< ProblemSetter, Real, ConfigTag, true >
class	SolverMonitor
	Base class for solver monitors. More...
class	SolverMonitorThread
	A RAII wrapper for launching the SolverMonitor's main loop in a separate thread. More...
class	SolverStarter
class	SolverStarterExplicitSolverSetter
class	SolverStarterExplicitSolverSetter< Problem, ExplicitSolverTag, ConfigTag, false >
class	SolverStarterExplicitSolverSetter< Problem, ExplicitSolverTag, ConfigTag, true >
class	SolverStarterTimeDiscretisationSetter
class	SolverStarterTimeDiscretisationSetter< Problem, ExplicitTimeDiscretisationTag, ConfigTag, true >
class	SolverStarterTimeDiscretisationSetter< Problem, ImplicitTimeDiscretisationTag, ConfigTag, true >
class	SolverStarterTimeDiscretisationSetter< Problem, SemiImplicitTimeDiscretisationTag, ConfigTag, true >
class	SolverStarterTimeDiscretisationSetter< Problem, TimeDiscretisationTag, ConfigTag, false >
class	StaticIterativeSolver
	Base class for iterative solvers. More...
class	TimeDependencyResolver
class	TimeDependencyResolver< Problem, ConfigTag, false >
class	TimeDependencyResolver< Problem, ConfigTag, true >
class	UserDefinedTimeDiscretisationSetter
class	UserDefinedTimeDiscretisationSetter< Problem, ConfigTag, void >

Functions
template<typename MatrixType>
std::shared_ptr< Linear::LinearSolver< MatrixType > >	getLinearSolver (const std::string &name)
	Function returning shared pointer with linear solver given by its name in a form of a string.
std::vector< std::string >	getLinearSolverOptions ()
	Function returning available linear solvers.
template<typename MatrixType>
std::shared_ptr< Linear::Preconditioners::Preconditioner< MatrixType > >	getPreconditioner (const std::string &name)
	Function returning shared pointer with linear preconditioner given by its name in a form of a string.
std::vector< std::string >	getPreconditionerOptions ()
	Function returning available linear preconditioners.

Detailed Description

Namespace for solvers.

Function Documentation

getLinearSolver()

template<typename MatrixType>

std::shared_ptr< Linear::LinearSolver< MatrixType > > TNL::Solvers::getLinearSolver

(

const std::string &

name

)

Function returning shared pointer with linear solver given by its name in a form of a string.

Template Parameters

MatrixType

is a type of matrix defining the system of linear equations.

Parameters

name

of the linear solver. The name can be one of the following: jacobi - for the Jacobi solver - TNL::Solvers::Linear::Jacobi. sor - for SOR solver - TNL::Solvers::Linear::SOR. cg - for CG solver - TNL::Solvers::Linear::CG. bicgstab - for BICGStab solver - TNL::Solvers::Linear::BICGStab. bicgstabl - for BICGStab(l) solver - TNL::Solvers::Linear::BICGStabL. gmres - for GMRES solver - TNL::Solvers::Linear::GMRES. tfqmr - for TFQMR solver - TNL::Solvers::Linear::TFQMR. idrs - for IDR(s) solver - TNL::Solvers::Linear::IDRs.

Returns

shared pointer with given linear solver.

The following example shows how to use this function:

#include <iostream>
#include <memory>
#include <TNL/Matrices/SparseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Solvers/LinearSolverTypeResolver.h>
 
template< typename Device >
void
iterativeLinearSolverExample()
{
   /***
    * Set the following matrix (dots represent zero matrix elements):
    *
    *   /  2.5 -1    .    .    .   \
    *   | -1    2.5 -1    .    .   |
    *   |  .   -1    2.5 -1.   .   |
    *   |  .    .   -1    2.5 -1   |
    *   \  .    .    .   -1    2.5 /
    */
   using MatrixType = TNL::Matrices::SparseMatrix< double, Device >;
   using Vector = TNL::Containers::Vector< double, Device >;
   const int size( 5 );
   auto matrix_ptr = std::make_shared< MatrixType >();
   matrix_ptr->setDimensions( size, size );
   matrix_ptr->setRowCapacities( Vector( { 2, 3, 3, 3, 2 } ) );
 
   auto f = [ = ] __cuda_callable__( typename MatrixType::RowView & row ) mutable
   {
      const int rowIdx = row.getRowIndex();
      if( rowIdx == 0 ) {
         row.setElement( 0, rowIdx, 2.5 );     // diagonal element
         row.setElement( 1, rowIdx + 1, -1 );  // element above the diagonal
      }
      else if( rowIdx == size - 1 ) {
         row.setElement( 0, rowIdx - 1, -1.0 );  // element below the diagonal
         row.setElement( 1, rowIdx, 2.5 );       // diagonal element
      }
      else {
         row.setElement( 0, rowIdx - 1, -1.0 );  // element below the diagonal
         row.setElement( 1, rowIdx, 2.5 );       // diagonal element
         row.setElement( 2, rowIdx + 1, -1.0 );  // element above the diagonal
      }
   };
 
   /***
    * Set the matrix elements.
    */
   matrix_ptr->forAllRows( f );
   std::cout << *matrix_ptr << std::endl;
 
   /***
    * Set the right-hand side vector.
    */
   Vector x( size, 1.0 );
   Vector b( size );
   matrix_ptr->vectorProduct( x, b );
   x = 0.0;
   std::cout << "Vector b = " << b << std::endl;
 
   /***
    * Solve the linear system using diagonal (Jacobi) preconditioner.
    */
   auto solver_ptr = TNL::Solvers::getLinearSolver< MatrixType >( "tfqmr" );
   auto preconditioner_ptr = TNL::Solvers::getPreconditioner< MatrixType >( "diagonal" );
   preconditioner_ptr->update( matrix_ptr );
   solver_ptr->setMatrix( matrix_ptr );
   solver_ptr->setPreconditioner( preconditioner_ptr );
   solver_ptr->setConvergenceResidue( 1.0e-6 );
   solver_ptr->solve( b, x );
   std::cout << "Vector x = " << x << std::endl;
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Solving linear system on host: " << std::endl;
   iterativeLinearSolverExample< TNL::Devices::Sequential >();
 
#ifdef __CUDACC__
   std::cout << "Solving linear system on CUDA device: " << std::endl;
   iterativeLinearSolverExample< TNL::Devices::Cuda >();
#endif
}

The result looks as follows:

Solving linear system on host: 
Row: 0 ->     0:2.5     1:-1  
Row: 1 ->     0:-1      1:2.5     2:-1  
Row: 2 ->     1:-1      2:2.5     3:-1  
Row: 3 ->     2:-1      3:2.5     4:-1  
Row: 4 ->     3:-1      4:2.5 
 
Vector b = [ 1.5, 0.5, 0.5, 0.5, 1.5 ]
Vector x = [ 1, 1, 1, 1, 1 ]
Solving linear system on CUDA device: 
Row: 0 ->     0:2.5     1:-1  
Row: 1 ->     0:-1      1:2.5     2:-1  
Row: 2 ->     1:-1      2:2.5     3:-1  
Row: 3 ->     2:-1      3:2.5     4:-1  
Row: 4 ->     3:-1      4:2.5 
 
Vector b = [ 1.5, 0.5, 0.5, 0.5, 1.5 ]
Vector x = [ 1, 1, 1, 1, 1 ]

getLinearSolverOptions()

std::vector< std::string > TNL::Solvers::getLinearSolverOptions ( )

inline

Function returning available linear solvers.

Returns

container with names of available linear solvers.

getPreconditioner()

template<typename MatrixType>

std::shared_ptr< Linear::Preconditioners::Preconditioner< MatrixType > > TNL::Solvers::getPreconditioner

(

const std::string &

name

)

Function returning shared pointer with linear preconditioner given by its name in a form of a string.

Template Parameters

MatrixType

is a type of matrix defining the system of linear equations.

Parameters

name

of the linear preconditioner. The name can be one of the following: none - for none preconditioner diagonal - for diagonal/Jacobi preconditioner - TNL::Solvers::Linear::Preconditioners::Diagonal ilu0 - for ILU(0) preconditioner - TNL::Solvers::Linear::Preconditioners::ILU0 ilut - for ILU with thresholding preconditioner - TNL::Solvers::Linear::Preconditioners::ILUT

Returns

shared pointer with given linear preconditioner.

#include <iostream>
#include <memory>
#include <TNL/Matrices/SparseMatrix.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Solvers/LinearSolverTypeResolver.h>
 
template< typename Device >
void
iterativeLinearSolverExample()
{
   /***
    * Set the following matrix (dots represent zero matrix elements):
    *
    *   /  2.5 -1    .    .    .   \
    *   | -1    2.5 -1    .    .   |
    *   |  .   -1    2.5 -1.   .   |
    *   |  .    .   -1    2.5 -1   |
    *   \  .    .    .   -1    2.5 /
    */
   using MatrixType = TNL::Matrices::SparseMatrix< double, Device >;
   using Vector = TNL::Containers::Vector< double, Device >;
   const int size( 5 );
   auto matrix_ptr = std::make_shared< MatrixType >();
   matrix_ptr->setDimensions( size, size );
   matrix_ptr->setRowCapacities( Vector( { 2, 3, 3, 3, 2 } ) );
 
   auto f = [ = ] __cuda_callable__( typename MatrixType::RowView & row ) mutable
   {
      const int rowIdx = row.getRowIndex();
      if( rowIdx == 0 ) {
         row.setElement( 0, rowIdx, 2.5 );     // diagonal element
         row.setElement( 1, rowIdx + 1, -1 );  // element above the diagonal
      }
      else if( rowIdx == size - 1 ) {
         row.setElement( 0, rowIdx - 1, -1.0 );  // element below the diagonal
         row.setElement( 1, rowIdx, 2.5 );       // diagonal element
      }
      else {
         row.setElement( 0, rowIdx - 1, -1.0 );  // element below the diagonal
         row.setElement( 1, rowIdx, 2.5 );       // diagonal element
         row.setElement( 2, rowIdx + 1, -1.0 );  // element above the diagonal
      }
   };
 
   /***
    * Set the matrix elements.
    */
   matrix_ptr->forAllRows( f );
   std::cout << *matrix_ptr << std::endl;
 
   /***
    * Set the right-hand side vector.
    */
   Vector x( size, 1.0 );
   Vector b( size );
   matrix_ptr->vectorProduct( x, b );
   x = 0.0;
   std::cout << "Vector b = " << b << std::endl;
 
   /***
    * Solve the linear system using diagonal (Jacobi) preconditioner.
    */
   auto solver_ptr = TNL::Solvers::getLinearSolver< MatrixType >( "tfqmr" );
   auto preconditioner_ptr = TNL::Solvers::getPreconditioner< MatrixType >( "diagonal" );
   preconditioner_ptr->update( matrix_ptr );
   solver_ptr->setMatrix( matrix_ptr );
   solver_ptr->setPreconditioner( preconditioner_ptr );
   solver_ptr->setConvergenceResidue( 1.0e-6 );
   solver_ptr->solve( b, x );
   std::cout << "Vector x = " << x << std::endl;
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Solving linear system on host: " << std::endl;
   iterativeLinearSolverExample< TNL::Devices::Sequential >();
 
#ifdef __CUDACC__
   std::cout << "Solving linear system on CUDA device: " << std::endl;
   iterativeLinearSolverExample< TNL::Devices::Cuda >();
#endif
}

The result looks as follows:

Solving linear system on host: 
Row: 0 ->     0:2.5     1:-1  
Row: 1 ->     0:-1      1:2.5     2:-1  
Row: 2 ->     1:-1      2:2.5     3:-1  
Row: 3 ->     2:-1      3:2.5     4:-1  
Row: 4 ->     3:-1      4:2.5 
 
Vector b = [ 1.5, 0.5, 0.5, 0.5, 1.5 ]
Vector x = [ 1, 1, 1, 1, 1 ]
Solving linear system on CUDA device: 
Row: 0 ->     0:2.5     1:-1  
Row: 1 ->     0:-1      1:2.5     2:-1  
Row: 2 ->     1:-1      2:2.5     3:-1  
Row: 3 ->     2:-1      3:2.5     4:-1  
Row: 4 ->     3:-1      4:2.5 
 
Vector b = [ 1.5, 0.5, 0.5, 0.5, 1.5 ]
Vector x = [ 1, 1, 1, 1, 1 ]

getPreconditionerOptions()

std::vector< std::string > TNL::Solvers::getPreconditionerOptions ( )

inline

Function returning available linear preconditioners.

Returns

container with names of available linear preconditioners.