#include <complex_smoother.h>

Inheritance diagram for oomph::HelmholtzSmoother:

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

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

virtual void	complex_smoother_solve (const Vector< DoubleVector > &rhs, Vector< DoubleVector > &result)=0

virtual void	complex_smoother_setup (Vector< CRDoubleMatrix * > matrix_pt)=0
	Setup the smoother for the matrix specified by the pointer. More...

void	complex_matrix_multiplication (Vector< CRDoubleMatrix * > matrices_pt, const Vector< DoubleVector > &x, Vector< DoubleVector > &soln)

template<typename MATRIX >
void	check_validity_of_solve_helper_inputs (CRDoubleMatrix const &real_matrix_pt, CRDoubleMatrix const &imag_matrix_pt, const Vector< DoubleVector > &rhs, Vector< 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

Helmholtz smoother class: The smoother class is designed for the Helmholtz equation 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

◆ HelmholtzSmoother()

oomph::HelmholtzSmoother::HelmholtzSmoother ( )

inline

Empty constructor.

49 : Use_as_smoother(false) {}

oomph::HelmholtzSmoother::Use_as_smoother

bool Use_as_smoother

Definition: complex_smoother.h:176

◆ ~HelmholtzSmoother()

virtual oomph::HelmholtzSmoother::~HelmholtzSmoother ( )

inlinevirtual

Virtual empty destructor.

52 {};

Member Function Documentation

◆ check_validity_of_solve_helper_inputs()

template<typename MATRIX >

void oomph::HelmholtzSmoother::check_validity_of_solve_helper_inputs	(	CRDoubleMatrix *const &	real_matrix_pt,
		CRDoubleMatrix *const &	imag_matrix_pt,
		const Vector< DoubleVector > &	rhs,
		Vector< 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.

   {
     // Number of dof types should be 2 (real & imaginary)
     unsigned n_dof_types = 2;
  
     // Create a vector to hold the matrices
     Vector<CRDoubleMatrix*> matrix_storage_pt(2, 0);
  
     // Assign the first entry in matrix_storage_pt
     matrix_storage_pt[0] = real_matrix_pt;
  
     // Assign the second entry in matrix_storage_pt
     matrix_storage_pt[1] = imag_matrix_pt;
  
     // Loop over the real and imaginary parts
     for (unsigned dof_type = 0; dof_type < n_dof_types; dof_type++)
     {
       // Check if the matrix is distributable. If it is then it should
       // not be distributed
       if (dynamic_cast<DistributableLinearAlgebraObject*>(
             matrix_storage_pt[dof_type]) != 0)
       {
         if (dynamic_cast<DistributableLinearAlgebraObject*>(
               matrix_storage_pt[dof_type])
               ->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);
         }
       }
       // Check that this rhs distribution is setup
       if (!(rhs[dof_type].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[dof_type].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[dof_type].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[dof_type].built())
       {
         if (!(*rhs[dof_type].distribution_pt() ==
               *solution[dof_type].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[0].built())||(solution[1].built()))
     } // for (unsigned dof_type=0;dof_type<n_dof_types;dof_type)
   } // End of check_validity_of_solve_helper_inputs

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

◆ complex_matrix_multiplication()

void oomph::HelmholtzSmoother::complex_matrix_multiplication	(	Vector< CRDoubleMatrix * >	matrices_pt,
		const Vector< DoubleVector > &	x,
		Vector< DoubleVector > &	soln
	)

inline

Helper function to calculate a complex matrix-vector product. Assumes the matrix has been provided as a Vector of length two; the first entry containing the real part of the system matrix and the second entry containing the imaginary part

     {
 #ifdef PARANOID
       // PARANOID check - Make sure the input matrix has the right size
       if (matrices_pt.size() != 2)
       {
         // Create an output stream
         std::ostringstream error_message_stream;
  
         // Create the error message
         error_message_stream << "Can only deal with two matrices. You have "
                              << matrices_pt.size() << " matrices." << std::endl;
  
         // Throw an error
         throw OomphLibError(error_message_stream.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
       // PARANOID check - Make sure the vector x has the right size
       if (x.size() != 2)
       {
         // Create an output stream
         std::ostringstream error_message_stream;
  
         // Create the error message
         error_message_stream
           << "Can only deal with two input vectors. You have " << x.size()
           << " vectors." << std::endl;
  
         // Throw an error
         throw OomphLibError(error_message_stream.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
       // PARANOID check - Make sure the vector soln has the right size
       if (soln.size() != 2)
       {
         // Create an output stream
         std::ostringstream error_message_stream;
  
         // Create the error message
         error_message_stream
           << "Can only deal with two output vectors. You have " << soln.size()
           << " output vectors." << std::endl;
  
         // Throw an error
         throw OomphLibError(error_message_stream.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       //-----------------------------------------------------------------------
       // Suppose we have a complex matrix, A, and two complex vectors, x and
       // soln. We wish to compute the product A*x=soln (note, * does not mean
       // we are using complex conjugates here, it is simply used to indicate
       // a multiplication). To do this we must make use of the fact that we
       // possess the real and imaginary separately. As a result, it is computed
       // using:
       //           soln = A*x,
       //                = (A_r + i*A_c)*(x_r + i*x_c),
       //                = [A_r*x_r - A_c*x_c] + i*[A_r*x_c + A_c*x_r],
       // ==> real(soln) = A_r*x_r - A_c*x_c,
       //   & imag(soln) = A_r*x_c + A_c*x_r,
       // where the subscripts _r and _c are used to identify the real and
       // imaginary part, respectively.
       //-----------------------------------------------------------------------
  
       // Store the value of A_r*x_r in the real part of soln
       matrices_pt[0]->multiply(x[0], soln[0]);
  
       // Store the value of A_r*x_c in the imaginary part of soln
       matrices_pt[0]->multiply(x[1], soln[1]);
  
       // Create a temporary vector
       DoubleVector temp(this->distribution_pt(), 0.0);
  
       // Calculate the value of A_c*x_c
       matrices_pt[1]->multiply(x[1], temp);
  
       // Subtract the value of temp from soln[0] to get the real part of soln
       soln[0] -= temp;
  
       // Calculate the value of A_c*x_r
       matrices_pt[1]->multiply(x[0], temp);
  
       // Add the value of temp to soln[1] to get the imaginary part of soln
       soln[1] += temp;
     } // End of complex_matrix_multiplication

References oomph::DistributableLinearAlgebraObject::distribution_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and plotDoE::x.

◆ complex_smoother_setup()

virtual void oomph::HelmholtzSmoother::complex_smoother_setup ( Vector< CRDoubleMatrix * > matrix_pt )

pure virtual

Setup the smoother for the matrix specified by the pointer.

Implemented in oomph::ComplexGMRES< MATRIX >, and oomph::ComplexDampedJacobi< MATRIX >.

◆ complex_smoother_solve()

virtual void oomph::HelmholtzSmoother::complex_smoother_solve	(	const Vector< DoubleVector > &	rhs,
		Vector< 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.

Implemented in oomph::ComplexGMRES< MATRIX >, and oomph::ComplexDampedJacobi< MATRIX >.

Member Data Documentation

◆ Use_as_smoother

bool oomph::HelmholtzSmoother::Use_as_smoother

protected

When a derived class object is being used as a smoother in the MG algorithm the residual norm does not need to be calculated. This boolean is used as a flag to indicate this in solve_helper(...)

Referenced by oomph::ComplexDampedJacobi< MATRIX >::complex_smoother_solve(), and oomph::ComplexGMRES< MATRIX >::complex_smoother_solve().

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

complex_smoother.h

Public Member Functions

Protected Attributes

Additional Inherited Members