#include <iterative_linear_solver.h>

Inheritance diagram for oomph::Smoother:

Public Member Functions
	Smoother ()
	Empty constructor. More...

virtual	~Smoother ()
	Virtual empty destructor. More...

virtual void	smoother_solve (const DoubleVector &rhs, DoubleVector &result)=0

virtual void	smoother_setup (DoubleMatrixBase *matrix_pt)=0
	Set up the smoother for the matrix specified by the pointer. More...

template<typename MATRIX >
void	check_validity_of_solve_helper_inputs (MATRIX *const &matrix_pt, const DoubleVector &rhs, DoubleVector &solution, const double &n_dof)

Public Member Functions inherited from oomph::IterativeLinearSolver
	IterativeLinearSolver ()

	IterativeLinearSolver (const IterativeLinearSolver &)=delete
	Broken copy constructor. More...

void	operator= (const IterativeLinearSolver &)=delete
	Broken assignment operator. More...

virtual	~IterativeLinearSolver ()
	Destructor (empty) More...

Preconditioner *&	preconditioner_pt ()
	Access function to preconditioner. More...

Preconditioner *const &	preconditioner_pt () const
	Access function to preconditioner (const version) More...

double &	tolerance ()
	Access to convergence tolerance. More...

unsigned &	max_iter ()
	Access to max. number of iterations. More...

virtual unsigned	iterations () const =0
	Number of iterations taken. More...

void	enable_doc_convergence_history ()
	Enable documentation of the convergence history. More...

void	disable_doc_convergence_history ()
	Disable documentation of the convergence history. More...

void	open_convergence_history_file_stream (const std::string &file_name, const std::string &zone_title="")

void	close_convergence_history_file_stream ()
	Close convergence history output stream. More...

double	jacobian_setup_time () const

double	linear_solver_solution_time () const
	return the time taken to solve the linear system More...

virtual double	preconditioner_setup_time () const
	returns the the time taken to setup the preconditioner More...

void	enable_setup_preconditioner_before_solve ()
	Setup the preconditioner before the solve. More...

void	disable_setup_preconditioner_before_solve ()
	Don't set up the preconditioner before the solve. More...

void	enable_error_after_max_iter ()
	Throw an error if we don't converge within max_iter. More...

void	disable_error_after_max_iter ()
	Don't throw an error if we don't converge within max_iter (default). More...

void	enable_iterative_solver_as_preconditioner ()

void	disable_iterative_solver_as_preconditioner ()

Public Member Functions inherited from oomph::LinearSolver
	LinearSolver ()
	Empty constructor, initialise the member data. More...

	LinearSolver (const LinearSolver &dummy)=delete
	Broken copy constructor. More...

void	operator= (const LinearSolver &)=delete
	Broken assignment operator. More...

virtual	~LinearSolver ()
	Empty virtual destructor. More...

void	enable_doc_time ()
	Enable documentation of solve times. More...

void	disable_doc_time ()
	Disable documentation of solve times. More...

bool	is_doc_time_enabled () const
	Is documentation of solve times enabled? More...

bool	is_resolve_enabled () const
	Boolean flag indicating if resolves are enabled. More...

virtual void	enable_resolve ()

virtual void	disable_resolve ()

virtual void	solve (Problem *const &problem_pt, DoubleVector &result)=0

virtual void	solve (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &result)

virtual void	solve (DoubleMatrixBase *const &matrix_pt, const Vector< double > &rhs, Vector< double > &result)

virtual void	solve_transpose (Problem *const &problem_pt, DoubleVector &result)

virtual void	solve_transpose (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &result)

virtual void	solve_transpose (DoubleMatrixBase *const &matrix_pt, const Vector< double > &rhs, Vector< double > &result)

virtual void	resolve (const DoubleVector &rhs, DoubleVector &result)

virtual void	resolve_transpose (const DoubleVector &rhs, DoubleVector &result)

virtual void	clean_up_memory ()

virtual void	enable_computation_of_gradient ()

void	disable_computation_of_gradient ()

void	reset_gradient ()

void	get_gradient (DoubleVector &gradient)
	function to access the gradient, provided it has been computed More...

Public Member Functions inherited from oomph::DistributableLinearAlgebraObject
	DistributableLinearAlgebraObject ()
	Default constructor - create a distribution. More...

	DistributableLinearAlgebraObject (const DistributableLinearAlgebraObject &matrix)=delete
	Broken copy constructor. More...

void	operator= (const DistributableLinearAlgebraObject &)=delete
	Broken assignment operator. More...

virtual	~DistributableLinearAlgebraObject ()
	Destructor. More...

LinearAlgebraDistribution *	distribution_pt () const
	access to the LinearAlgebraDistribution More...

unsigned	nrow () const
	access function to the number of global rows. More...

unsigned	nrow_local () const
	access function for the num of local rows on this processor. More...

unsigned	nrow_local (const unsigned &p) const
	access function for the num of local rows on this processor. More...

unsigned	first_row () const
	access function for the first row on this processor More...

unsigned	first_row (const unsigned &p) const
	access function for the first row on this processor More...

bool	distributed () const
	distribution is serial or distributed More...

bool	distribution_built () const

void	build_distribution (const LinearAlgebraDistribution *const dist_pt)

void	build_distribution (const LinearAlgebraDistribution &dist)

Protected Attributes
bool	Use_as_smoother

Protected Attributes inherited from oomph::IterativeLinearSolver
bool	Doc_convergence_history

std::ofstream	Output_file_stream
	Output file stream for convergence history. More...

double	Tolerance
	Convergence tolerance. More...

unsigned	Max_iter
	Maximum number of iterations. More...

Preconditioner *	Preconditioner_pt
	Pointer to the preconditioner. More...

double	Jacobian_setup_time
	Jacobian setup time. More...

double	Solution_time
	linear solver solution time More...

double	Preconditioner_setup_time
	Preconditioner setup time. More...

bool	Setup_preconditioner_before_solve

bool	Throw_error_after_max_iter

bool	Use_iterative_solver_as_preconditioner
	Use the iterative solver as preconditioner. More...

bool	First_time_solve_when_used_as_preconditioner

Protected Attributes inherited from oomph::LinearSolver
bool	Enable_resolve

bool	Doc_time
	Boolean flag that indicates whether the time taken. More...

bool	Compute_gradient

bool	Gradient_has_been_computed
	flag that indicates whether the gradient was computed or not More...

DoubleVector	Gradient_for_glob_conv_newton_solve

Additional Inherited Members
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()

Static Protected Attributes inherited from oomph::IterativeLinearSolver
static IdentityPreconditioner	Default_preconditioner

Detailed Description

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Smoother class: The smoother class is designed for to be used in conjunction with multigrid. The action of the smoother should reduce the high frequency errors. These methods are inefficient as stand-alone solvers.

Constructor & Destructor Documentation

◆ Smoother()

oomph::Smoother::Smoother ( )

inline

Empty constructor.

553 : Use_as_smoother(false) {}

oomph::Smoother::Use_as_smoother

bool Use_as_smoother

Definition: iterative_linear_solver.h:585

◆ ~Smoother()

virtual oomph::Smoother::~Smoother ( )

inlinevirtual

Virtual empty destructor.

556 {};

Member Function Documentation

◆ check_validity_of_solve_helper_inputs()

template<typename MATRIX >

void oomph::Smoother::check_validity_of_solve_helper_inputs	(	MATRIX *const &	matrix_pt,
		const DoubleVector &	rhs,
		DoubleVector &	solution,
		const double &	n_dof
	)

Self-test to check that all the dimensions of the inputs to solve helper are consistent and everything that needs to be built, is.

/////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// Self-test to be called inside solve_helper to ensure that all inputs are consistent and everything that needs to be built, is.

   {
     // Check that if the matrix is not distributable then it should not
     // be distributed
     if (dynamic_cast<DistributableLinearAlgebraObject*>(matrix_pt) != 0)
     {
       if (dynamic_cast<DistributableLinearAlgebraObject*>(matrix_pt)
             ->distributed())
       {
         std::ostringstream error_message_stream;
         error_message_stream << "The matrix must not be distributed.";
         throw OomphLibError(error_message_stream.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
     } // if (dynamic_cast<DistributableLinearAlgebraObject*>(matrix_pt)!=0)
     // Check that this rhs distribution is setup
     if (!rhs.built())
     {
       std::ostringstream error_message_stream;
       error_message_stream << "The rhs vector distribution must be setup.";
       throw OomphLibError(error_message_stream.str(),
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
     // Check that the rhs has the right number of global rows
     if (rhs.nrow() != n_dof)
     {
       std::ostringstream error_message_stream;
       error_message_stream << "RHS does not have the same dimension as "
                            << "the linear system";
       throw OomphLibError(error_message_stream.str(),
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
     // Check that the rhs is not distributed
     if (rhs.distribution_pt()->distributed())
     {
       std::ostringstream error_message_stream;
       error_message_stream << "The rhs vector must not be distributed.";
       throw OomphLibError(error_message_stream.str(),
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
     // Check that if the result is setup it matches the distribution
     // of the rhs
     if (solution.built())
     {
       if (!(*rhs.distribution_pt() == *solution.distribution_pt()))
       {
         std::ostringstream error_message_stream;
         error_message_stream << "If the result distribution is setup then it "
                              << "must be the same as the rhs distribution";
         throw OomphLibError(error_message_stream.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
     } // if (solution.built())
   } // End of check_validity_of_solve_helper_inputs

References oomph::DoubleVector::built(), oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::DistributableLinearAlgebraObject::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and BiharmonicTestFunctions1::solution().

◆ smoother_setup()

virtual void oomph::Smoother::smoother_setup ( DoubleMatrixBase * matrix_pt )

pure virtual

Set up the smoother for the matrix specified by the pointer.

Implemented in oomph::DampedJacobi< MATRIX >, oomph::GS< CRDoubleMatrix >, and oomph::GS< MATRIX >.

◆ smoother_solve()

virtual void oomph::Smoother::smoother_solve	(	const DoubleVector &	rhs,
		DoubleVector &	result
	)

pure virtual

The smoother_solve function performs fixed number of iterations on the system A*result=rhs. The number of (smoothing) iterations is the same as the max. number of iterations in the underlying IterativeLinearSolver class. Note that the result vector MUST NOT re-initialised to zero (as it would typically be when the Smoother is called as a iterative linear solver).

Implemented in oomph::DampedJacobi< MATRIX >, oomph::GS< CRDoubleMatrix >, and oomph::GS< MATRIX >.

Member Data Documentation

◆ Use_as_smoother

bool oomph::Smoother::Use_as_smoother

protected

When a derived class object is being used as a smoother in the MG solver (or elsewhere) the residual norm does not need to be calculated because we're simply performing a fixed number of (smoothing) iterations. This boolean is used as a flag to indicate that the IterativeLinearSolver (which this class is by inheritance) is supposed to act in this way.

Referenced by oomph::GS< MATRIX >::smoother_solve(), oomph::GS< CRDoubleMatrix >::smoother_solve(), oomph::DampedJacobi< MATRIX >::smoother_solve(), oomph::GS< MATRIX >::solve(), oomph::DampedJacobi< MATRIX >::solve(), oomph::GS< CRDoubleMatrix >::solve(), and oomph::GS< CRDoubleMatrix >::solve_helper().

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

Public Member Functions

Protected Attributes

Additional Inherited Members