TNL::Solvers::IterativeSolverMonitor< Real > Class Template Reference

Object for monitoring convergence of iterative solvers. More...

#include <TNL/Solvers/IterativeSolverMonitor.h>

Inheritance diagram for TNL::Solvers::IterativeSolverMonitor< Real >:

Collaboration diagram for TNL::Solvers::IterativeSolverMonitor< Real >:

Public Types
using	IndexType = std::size_t
	A type for indexing.
using	RealType = Real
	A type of the floating-point arithmetics.

Public Member Functions
	IterativeSolverMonitor ()=default
	Construct with no parameters.
void	refresh () override
	Causes that the monitor prints out the status of the solver.
void	setIterations (const IndexType &iterations)
	Set number of the current iteration.
void	setNodesPerIteration (const IndexType &nodes)
	Set the number of nodes of the numerical mesh or lattice.
void	setResidue (const RealType &residue)
	Set residue of the current approximation of the solution.
void	setStage (const std::string &stage)
	This method can be used for naming a stage of the monitored solver.
void	setTime (const RealType &time)
	Set the time of the simulated evolution if it is time dependent.
void	setTimeStep (const RealType &timeStep)
	Set the time step for time dependent iterative solvers.
void	setVerbose (const IndexType &verbose)
	Set up the verbosity of the monitor.
Public Member Functions inherited from TNL::Solvers::SolverMonitor
	SolverMonitor ()=default
	Basic construct with no arguments.
bool	isStopped () const
	Checks whether the main loop was stopped.
void	runMainLoop ()
	Starts the main loop from which the method SolverMonitor::refresh is called in given time periods.
void	setRefreshRate (const int &refreshRate)
	Set the time interval between two consecutive calls of SolverMonitor::refresh.
void	setTimer (Timer &timer)
	Set a timer object for the solver monitor.
void	stopMainLoop ()
	Stops the main loop of the monitor. See runMainLoop.
void	unsetTimer ()
	Unsets the timer object for the solver monitor.

Protected Member Functions
int	getLineWidth ()
Protected Member Functions inherited from TNL::Solvers::SolverMonitor
double	getElapsedTime ()

Protected Attributes
std::atomic_bool	attributes_changed { false }
RealType	elapsed_time_before_refresh = 0
IndexType	iterations = 0
IndexType	iterations_before_refresh = 0
RealType	last_mlups = 0
IndexType	nodesPerIteration = 0
RealType	residue = 0
std::atomic_bool	saved { false }
IndexType	saved_iterations = 0
RealType	saved_residue = 0
std::string	saved_stage
RealType	saved_time = 0
RealType	saved_timeStep = 0
std::string	stage
RealType	time = 0
RealType	timeStep = 0
IndexType	verbose = 2
Protected Attributes inherited from TNL::Solvers::SolverMonitor
std::atomic_bool	started { false }
std::atomic_bool	stopped { false }
std::atomic_int	timeout_milliseconds { 500 }
Timer *	timer = nullptr

Detailed Description

template<typename Real = double>
class TNL::Solvers::IterativeSolverMonitor< Real >

Object for monitoring convergence of iterative solvers.

Template Parameters

Real	is a type of the floating-point arithmetics.
Index	is an indexing type.

The following example shows how to use the iterative solver monitor for monitoring convergence of linear iterative solver:

#include <iostream>
#include <memory>
#include <TNL/Matrices/SparseMatrix.h>
#include <TNL/Devices/Sequential.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Solvers/Linear/Jacobi.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 << '\n';
 
   /***
    * 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 << '\n';
 
   /***
    * Setup solver of the linear system.
    */
   using LinearSolver = TNL::Solvers::Linear::Jacobi< MatrixType >;
   LinearSolver solver;
   solver.setMatrix( matrix_ptr );
   solver.setOmega( 0.0005 );
 
   /***
    * Setup monitor of the iterative solver.
    */
   using IterativeSolverMonitorType = TNL::Solvers::IterativeSolverMonitor< double >;
   IterativeSolverMonitorType monitor;
   TNL::Solvers::SolverMonitorThread monitorThread( monitor );
   monitor.setRefreshRate( 10 );  // refresh rate in milliseconds
   monitor.setVerbose( 1 );
   monitor.setStage( "Jacobi stage:" );
   solver.setSolverMonitor( monitor );
   solver.setConvergenceResidue( 1.0e-6 );
   solver.solve( b, x );
   monitor.stopMainLoop();
   std::cout << "Vector x = " << x << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Solving linear system on host:\n";
   iterativeLinearSolverExample< TNL::Devices::Sequential >();
 
#ifdef __CUDACC__
   std::cout << "Solving linear system on CUDA device:\n";
   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 = [ 0.999999, 0.999999, 0.999998, 0.999999, 0.999999 ]

The following example shows how to employ timer (TNL::Timer) to the monitor of iterative solvers:

#include <iostream>
#include <memory>
#include <TNL/Timer.h>
#include <TNL/Matrices/SparseMatrix.h>
#include <TNL/Devices/Sequential.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Solvers/Linear/Jacobi.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 << '\n';
 
   /***
    * 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 << '\n';
 
   /***
    * Setup solver of the linear system.
    */
   using LinearSolver = TNL::Solvers::Linear::Jacobi< MatrixType >;
   LinearSolver solver;
   solver.setMatrix( matrix_ptr );
   solver.setOmega( 0.0005 );
 
   /***
    * Setup monitor of the iterative solver.
    */
   using IterativeSolverMonitorType = TNL::Solvers::IterativeSolverMonitor< double >;
   IterativeSolverMonitorType monitor;
   TNL::Solvers::SolverMonitorThread mmonitorThread( monitor );
   monitor.setRefreshRate( 10 );  // refresh rate in milliseconds
   monitor.setVerbose( 1 );
   monitor.setStage( "Jacobi stage:" );
   TNL::Timer timer;
   monitor.setTimer( timer );
   timer.start();
   solver.setSolverMonitor( monitor );
   solver.setConvergenceResidue( 1.0e-6 );
   solver.solve( b, x );
   monitor.stopMainLoop();
   std::cout << "Vector x = " << x << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Solving linear system on host:\n";
   iterativeLinearSolverExample< TNL::Devices::Sequential >();
 
#ifdef __CUDACC__
   std::cout << "Solving linear system on CUDA device:\n";
   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 ]
 ELA:5.06e-06
Vector x = [ 0.999999, 0.999999, 0.999998, 0.999999, 0.999999 ]

Member Function Documentation

refresh()

template<typename Real = double>

void TNL::Solvers::IterativeSolverMonitor< Real >::refresh ( )

overridevirtual

Causes that the monitor prints out the status of the solver.

Implements TNL::Solvers::SolverMonitor.

setIterations()

template<typename Real = double>

void TNL::Solvers::IterativeSolverMonitor< Real >::setIterations

(

const IndexType &

iterations

)

Set number of the current iteration.

Parameters

iterations

is number of the current iteration.

setNodesPerIteration()

template<typename Real = double>

void TNL::Solvers::IterativeSolverMonitor< Real >::setNodesPerIteration

(

const IndexType &

nodes

)

Set the number of nodes of the numerical mesh or lattice.

This can be used to compute the number of nodes processed per one second.

Parameters

nodes

is number of nodes of the numerical mesh or lattice.

setResidue()

template<typename Real = double>

void TNL::Solvers::IterativeSolverMonitor< Real >::setResidue

(

const RealType &

residue

)

Set residue of the current approximation of the solution.

Parameters

residue

is a residue of the current approximation of the solution.

setStage()

template<typename Real = double>

void TNL::Solvers::IterativeSolverMonitor< Real >::setStage

(

const std::string &

stage

)

This method can be used for naming a stage of the monitored solver.

The stage name can be used to differ between various stages of iterative solvers.

Parameters

stage

is name of the solver stage.

setTime()

template<typename Real = double>

void TNL::Solvers::IterativeSolverMonitor< Real >::setTime

(

const RealType &

time

)

Set the time of the simulated evolution if it is time dependent.

This can be used for example when solving parabolic or hyperbolic PDEs.

Parameters

time	time of the simulated evolution.

setTimeStep()

template<typename Real = double>

void TNL::Solvers::IterativeSolverMonitor< Real >::setTimeStep

(

const RealType &

timeStep

)

Set the time step for time dependent iterative solvers.

Parameters

timeStep

time step of the time dependent iterative solver.

setVerbose()

template<typename Real = double>

void TNL::Solvers::IterativeSolverMonitor< Real >::setVerbose

(

const IndexType &

verbose

)

Set up the verbosity of the monitor.

Parameters

verbose

is the new value of the verbosity of the monitor.

---

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

• src/TNL/Solvers/IterativeSolverMonitor.h