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

Template Numerical Library version\ main:be7e16d88

Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
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 >:
[legend]
Collaboration diagram for TNL::Solvers::IterativeSolverMonitor< Real >:
[legend]

## 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:

1#include <iostream>
2#include <memory>
3#include <TNL/Matrices/SparseMatrix.h>
4#include <TNL/Devices/Sequential.h>
5#include <TNL/Devices/Cuda.h>
6#include <TNL/Solvers/Linear/Jacobi.h>
7
8template< typename Device >
9void
10iterativeLinearSolverExample()
11{
12 /***
13 * Set the following matrix (dots represent zero matrix elements):
14 *
15 * / 2.5 -1 . . . \
16 * | -1 2.5 -1 . . |
17 * | . -1 2.5 -1. . |
18 * | . . -1 2.5 -1 |
19 * \ . . . -1 2.5 /
20 */
21 using MatrixType = TNL::Matrices::SparseMatrix< double, Device >;
22 using Vector = TNL::Containers::Vector< double, Device >;
23 const int size( 5 );
24 auto matrix_ptr = std::make_shared< MatrixType >();
25 matrix_ptr->setDimensions( size, size );
26 matrix_ptr->setRowCapacities( Vector( { 2, 3, 3, 3, 2 } ) );
27
28 auto f = [ = ] __cuda_callable__( typename MatrixType::RowView & row ) mutable
29 {
30 const int rowIdx = row.getRowIndex();
31 if( rowIdx == 0 ) {
32 row.setElement( 0, rowIdx, 2.5 ); // diagonal element
33 row.setElement( 1, rowIdx + 1, -1 ); // element above the diagonal
34 }
35 else if( rowIdx == size - 1 ) {
36 row.setElement( 0, rowIdx - 1, -1.0 ); // element below the diagonal
37 row.setElement( 1, rowIdx, 2.5 ); // diagonal element
38 }
39 else {
40 row.setElement( 0, rowIdx - 1, -1.0 ); // element below the diagonal
41 row.setElement( 1, rowIdx, 2.5 ); // diagonal element
42 row.setElement( 2, rowIdx + 1, -1.0 ); // element above the diagonal
43 }
44 };
45
46 /***
47 * Set the matrix elements.
48 */
49 matrix_ptr->forAllRows( f );
50 std::cout << *matrix_ptr << '\n';
51
52 /***
53 * Set the right-hand side vector.
54 */
55 Vector x( size, 1.0 );
56 Vector b( size );
57 matrix_ptr->vectorProduct( x, b );
58 x = 0.0;
59 std::cout << "Vector b = " << b << '\n';
60
61 /***
62 * Setup solver of the linear system.
63 */
64 using LinearSolver = TNL::Solvers::Linear::Jacobi< MatrixType >;
65 LinearSolver solver;
66 solver.setMatrix( matrix_ptr );
67 solver.setOmega( 0.0005 );
68
69 /***
70 * Setup monitor of the iterative solver.
71 */
72 using IterativeSolverMonitorType = TNL::Solvers::IterativeSolverMonitor< double >;
73 IterativeSolverMonitorType monitor;
74 TNL::Solvers::SolverMonitorThread monitorThread( monitor );
75 monitor.setRefreshRate( 10 ); // refresh rate in milliseconds
76 monitor.setVerbose( 1 );
77 monitor.setStage( "Jacobi stage:" );
78 solver.setSolverMonitor( monitor );
79 solver.setConvergenceResidue( 1.0e-6 );
80 solver.solve( b, x );
81 monitor.stopMainLoop();
82 std::cout << "Vector x = " << x << '\n';
83}
84
85int
86main( int argc, char* argv[] )
87{
88 std::cout << "Solving linear system on host:\n";
89 iterativeLinearSolverExample< TNL::Devices::Sequential >();
90
91#ifdef __CUDACC__
92 std::cout << "Solving linear system on CUDA device:\n";
93 iterativeLinearSolverExample< TNL::Devices::Cuda >();
94#endif
95}
__cuda_callable__
#define __cuda_callable__
Definition Macros.h:49
std::cout
TNL::Containers::Vector
Vector extends Array with algebraic operations.
Definition Vector.h:36
TNL::Matrices::SparseMatrix
Implementation of sparse matrix, i.e. matrix storing only non-zero elements.
Definition SparseMatrix.h:55
TNL::Solvers::IterativeSolverMonitor< double >
TNL::Solvers::Linear::Jacobi
Iterative solver of linear systems based on the Jacobi method.
Definition Jacobi.h:21
TNL::Solvers::Linear::LinearSolver::setMatrix
virtual void setMatrix(const MatrixPointer &matrix)
Set the matrix of the linear system.
Definition LinearSolver.h:120
TNL::Solvers::SolverMonitorThread
A RAII wrapper for launching the SolverMonitor's main loop in a separate thread.
Definition SolverMonitor.h:142
std::make_shared
T make_shared(T... args)

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:

1#include <iostream>
2#include <memory>
3#include <TNL/Timer.h>
4#include <TNL/Matrices/SparseMatrix.h>
5#include <TNL/Devices/Sequential.h>
6#include <TNL/Devices/Cuda.h>
7#include <TNL/Solvers/Linear/Jacobi.h>
8
9template< typename Device >
10void
11iterativeLinearSolverExample()
12{
13 /***
14 * Set the following matrix (dots represent zero matrix elements):
15 *
16 * / 2.5 -1 . . . \
17 * | -1 2.5 -1 . . |
18 * | . -1 2.5 -1. . |
19 * | . . -1 2.5 -1 |
20 * \ . . . -1 2.5 /
21 */
22 using MatrixType = TNL::Matrices::SparseMatrix< double, Device >;
23 using Vector = TNL::Containers::Vector< double, Device >;
24 const int size( 5 );
25 auto matrix_ptr = std::make_shared< MatrixType >();
26 matrix_ptr->setDimensions( size, size );
27 matrix_ptr->setRowCapacities( Vector( { 2, 3, 3, 3, 2 } ) );
28
29 auto f = [ = ] __cuda_callable__( typename MatrixType::RowView & row ) mutable
30 {
31 const int rowIdx = row.getRowIndex();
32 if( rowIdx == 0 ) {
33 row.setElement( 0, rowIdx, 2.5 ); // diagonal element
34 row.setElement( 1, rowIdx + 1, -1 ); // element above the diagonal
35 }
36 else if( rowIdx == size - 1 ) {
37 row.setElement( 0, rowIdx - 1, -1.0 ); // element below the diagonal
38 row.setElement( 1, rowIdx, 2.5 ); // diagonal element
39 }
40 else {
41 row.setElement( 0, rowIdx - 1, -1.0 ); // element below the diagonal
42 row.setElement( 1, rowIdx, 2.5 ); // diagonal element
43 row.setElement( 2, rowIdx + 1, -1.0 ); // element above the diagonal
44 }
45 };
46
47 /***
48 * Set the matrix elements.
49 */
50 matrix_ptr->forAllRows( f );
51 std::cout << *matrix_ptr << '\n';
52
53 /***
54 * Set the right-hand side vector.
55 */
56 Vector x( size, 1.0 );
57 Vector b( size );
58 matrix_ptr->vectorProduct( x, b );
59 x = 0.0;
60 std::cout << "Vector b = " << b << '\n';
61
62 /***
63 * Setup solver of the linear system.
64 */
65 using LinearSolver = TNL::Solvers::Linear::Jacobi< MatrixType >;
66 LinearSolver solver;
67 solver.setMatrix( matrix_ptr );
68 solver.setOmega( 0.0005 );
69
70 /***
71 * Setup monitor of the iterative solver.
72 */
73 using IterativeSolverMonitorType = TNL::Solvers::IterativeSolverMonitor< double >;
74 IterativeSolverMonitorType monitor;
75 TNL::Solvers::SolverMonitorThread mmonitorThread( monitor );
76 monitor.setRefreshRate( 10 ); // refresh rate in milliseconds
77 monitor.setVerbose( 1 );
78 monitor.setStage( "Jacobi stage:" );
79 TNL::Timer timer;
80 monitor.setTimer( timer );
81 timer.start();
82 solver.setSolverMonitor( monitor );
83 solver.setConvergenceResidue( 1.0e-6 );
84 solver.solve( b, x );
85 monitor.stopMainLoop();
86 std::cout << "Vector x = " << x << '\n';
87}
88
89int
90main( int argc, char* argv[] )
91{
92 std::cout << "Solving linear system on host:\n";
93 iterativeLinearSolverExample< TNL::Devices::Sequential >();
94
95#ifdef __CUDACC__
96 std::cout << "Solving linear system on CUDA device:\n";
97 iterativeLinearSolverExample< TNL::Devices::Cuda >();
98#endif
99}
TNL::Timer
Class for real time, CPU time and CPU cycles measuring.
Definition Timer.h:25
TNL::Timer::start
void start()
Starts timer.

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:1.8449e-
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