oomph::DampedJacobi< MATRIX > Class Template Reference

#include <iterative_linear_solver.h>

Inheritance diagram for oomph::DampedJacobi< MATRIX >:

Public Member Functions
	DampedJacobi (const double &omega=2.0/3.0)
	Empty constructor. More...
	~DampedJacobi ()
	Empty destructor. More...
	DampedJacobi (const DampedJacobi &)=delete
	Broken copy constructor. More...
void	operator= (const DampedJacobi &)=delete
	Broken assignment operator. More...
void	clean_up_memory ()
	Cleanup data that's stored for resolve (if any has been stored) More...
void	smoother_setup (DoubleMatrixBase *matrix_pt)
	Setup: Pass pointer to the matrix and store in cast form. More...
void	extract_diagonal_entries (DoubleMatrixBase *matrix_pt)
	Function to extract the diagonal entries from the matrix. More...
void	smoother_solve (const DoubleVector &rhs, DoubleVector &solution)
void	solve (Problem *const &problem_pt, DoubleVector &result)
void	solve (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &solution)
void	resolve (const DoubleVector &rhs, DoubleVector &result)
unsigned	iterations () const
	Number of iterations taken. More...
Public Member Functions inherited from oomph::Smoother
	Smoother ()
	Empty constructor. More...
virtual	~Smoother ()
	Virtual empty destructor. 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...
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 (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_transpose (const DoubleVector &rhs, DoubleVector &result)
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)

Private Member Functions
void	solve_helper (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &solution)

Private Attributes
MATRIX *	Matrix_pt
	Pointer to the matrix. More...
Vector< double >	Matrix_diagonal
	Vector containing the diagonal entries of A. More...
bool	Resolving
bool	Matrix_can_be_deleted
unsigned	Iterations
	Number of iterations taken. More...
double	Omega
	Damping factor. More...

Additional Inherited Members
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()
Protected Attributes inherited from oomph::Smoother
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
Static Protected Attributes inherited from oomph::IterativeLinearSolver
static IdentityPreconditioner	Default_preconditioner

Detailed Description

template<typename MATRIX>
class oomph::DampedJacobi< MATRIX >

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Damped Jacobi "solver" templated by matrix type. The "solver" exists in many different incarnations: It's an IterativeLinearSolver, and a Smoother, all of which use the same basic iteration.

Constructor & Destructor Documentation

DampedJacobi() [1/2]

template<typename MATRIX >

oomph::DampedJacobi< MATRIX >::DampedJacobi ( const double &  omega = 2.0 / 3.0 )

inline

Empty constructor.

                                                  : Matrix_can_be_deleted(true)
    {
      // Damping factor
      Omega = omega;
    }

References Eigen::internal::omega(), and oomph::DampedJacobi< MATRIX >::Omega.

~DampedJacobi()

template<typename MATRIX >

oomph::DampedJacobi< MATRIX >::~DampedJacobi ( )

inline

Empty destructor.

    {
      // Run the generic clean up function
      clean_up_memory();
    }

References oomph::DampedJacobi< MATRIX >::clean_up_memory().

DampedJacobi() [2/2]

template<typename MATRIX >

oomph::DampedJacobi< MATRIX >::DampedJacobi ( const DampedJacobi< MATRIX > &  )

delete

Broken copy constructor.

Member Function Documentation

clean_up_memory()

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::clean_up_memory ( )

inlinevirtual

Cleanup data that's stored for resolve (if any has been stored)

Reimplemented from oomph::LinearSolver.

    {
      // If the matrix pointer isn't null AND we're allowed to delete the
      // matrix which is only when we create the matrix ourselves
      if ((Matrix_pt != 0) && (Matrix_can_be_deleted))
      {
        // Delete the matrix
        delete Matrix_pt;
 
        // Assign the associated pointer the value NULL
        Matrix_pt = 0;
      }
    } // End of clean_up_memory

References oomph::DampedJacobi< MATRIX >::Matrix_can_be_deleted, and oomph::DampedJacobi< MATRIX >::Matrix_pt.

Referenced by oomph::DampedJacobi< MATRIX >::~DampedJacobi().

extract_diagonal_entries()

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::extract_diagonal_entries ( DoubleMatrixBase *  matrix_pt )

inline

Function to extract the diagonal entries from the matrix.

    {
      // If we're using a CRDoubleMatrix object
      if (dynamic_cast<CRDoubleMatrix*>(matrix_pt))
      {
        // The matrix diagonal (we need this when we need to calculate inv(D)
        // where D is the diagonal of A and it remains the same for all uses
        // of the iterative scheme so we can store it and call it in each
        // iteration)
        Matrix_diagonal =
          dynamic_cast<CRDoubleMatrix*>(Matrix_pt)->diagonal_entries();
      }
      // If we're using a complex matrix then diagonal entries has to be a
      // complex vector rather than a vector of doubles.
      else if (dynamic_cast<CCDoubleMatrix*>(matrix_pt))
      {
        // Make an ostringstream object to create an error message
        std::ostringstream error_message_stream;
 
        // Create the error message
        error_message_stream << "Damped Jacobi can only cater to real-valued "
                             << "matrices. If you require a complex-valued "
                             << "version, please write this yourself. "
                             << "It is likely that the only difference will be "
                             << "the use of complex vectors.";
 
        // Throw an error
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      // Just extract the diagonal entries normally
      else
      {
        // Calculate the number of rows in the matrix
        unsigned n_row = Matrix_pt->nrow();
 
        // Loop over the rows of the matrix
        for (unsigned i = 0; i < n_row; i++)
        {
          // Assign the i-th value of Matrix_diagonal
          Matrix_diagonal[i] = (*Matrix_pt)(i, i);
        }
      } // if (dynamic_cast<CRDoubleMatrix*>(matrix_pt))
 
      // Calculate the n.d.o.f.
      unsigned n_dof = Matrix_diagonal.size();
 
      // Find the reciprocal of the entries of Matrix_diagonal
      for (unsigned i = 0; i < n_dof; i++)
      {
        Matrix_diagonal[i] = 1.0 / Matrix_diagonal[i];
      }
    } // End of extract_diagonal_entries

References i, oomph::DampedJacobi< MATRIX >::Matrix_diagonal, oomph::DampedJacobi< MATRIX >::Matrix_pt, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::DampedJacobi< MATRIX >::smoother_setup(), and oomph::DampedJacobi< MATRIX >::solve().

iterations()

template<typename MATRIX >

unsigned oomph::DampedJacobi< MATRIX >::iterations ( ) const

inlinevirtual

Number of iterations taken.

Implements oomph::IterativeLinearSolver.

    {
      // Return the value of Iterations
      return Iterations;
    } // End of iterations

References oomph::DampedJacobi< MATRIX >::Iterations.

operator=()

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::operator= ( const DampedJacobi< MATRIX > &  )

delete

Broken assignment operator.

resolve()

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::resolve ( const DoubleVector &  rhs, DoubleVector &  result  )

inlinevirtual

Re-solve the system defined by the last assembled Jacobian and the rhs vector specified here. Solution is returned in the vector result.

Reimplemented from oomph::LinearSolver.

    {
      // We are re-solving
      Resolving = true;
 
#ifdef PARANOID
      if (Matrix_pt == 0)
      {
        throw OomphLibError("No matrix was stored -- cannot re-solve",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // Call linear algebra-style solver
      solve(Matrix_pt, rhs, result);
 
      // Reset re-solving flag
      Resolving = false;
    } // End of resolve

References oomph::DampedJacobi< MATRIX >::Matrix_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::DampedJacobi< MATRIX >::Resolving, and oomph::DampedJacobi< MATRIX >::solve().

smoother_setup()

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::smoother_setup ( DoubleMatrixBase *  matrix_pt )

inlinevirtual

Setup: Pass pointer to the matrix and store in cast form.

Implements oomph::Smoother.

    {
      // Assume the matrix has been passed in from the outside so we must not
      // delete it
      Matrix_can_be_deleted = false;
 
      // Upcast to the appropriate matrix type
      Matrix_pt = dynamic_cast<MATRIX*>(matrix_pt);
 
      // Extract the diagonal entries of the matrix and store them
      extract_diagonal_entries(matrix_pt);
    } // End of smoother_setup

References oomph::DampedJacobi< MATRIX >::extract_diagonal_entries(), oomph::DampedJacobi< MATRIX >::Matrix_can_be_deleted, and oomph::DampedJacobi< MATRIX >::Matrix_pt.

smoother_solve()

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::smoother_solve ( const DoubleVector &  rhs, DoubleVector &  solution  )

inlinevirtual

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.

Implements oomph::Smoother.

    {
      // If you use a smoother but you don't want to calculate the residual
      Use_as_smoother = true;
 
      // Call the helper function
      solve_helper(Matrix_pt, rhs, solution);
    } // End of smoother_solve

References oomph::DampedJacobi< MATRIX >::Matrix_pt, BiharmonicTestFunctions1::solution(), oomph::DampedJacobi< MATRIX >::solve_helper(), and oomph::Smoother::Use_as_smoother.

solve() [1/2]

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::solve ( DoubleMatrixBase *const &  matrix_pt, const DoubleVector &  rhs, DoubleVector &  solution  )

inlinevirtual

Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system.

Reimplemented from oomph::LinearSolver.

    {
      // Matrix has been passed in from the outside so we must not delete it
      Matrix_can_be_deleted = false;
 
      // Indicate that the solver is not being used as a smoother
      Use_as_smoother = false;
 
      // Set up the distribution
      this->build_distribution(rhs.distribution_pt());
 
      // Store the matrix if required
      if ((Enable_resolve) && (!Resolving))
      {
        // Upcast to the appropriate matrix type
        Matrix_pt = dynamic_cast<MATRIX*>(matrix_pt);
      }
 
      // Extract the diagonal entries of the matrix and store them
      extract_diagonal_entries(matrix_pt);
 
      // Call the helper function
      solve_helper(matrix_pt, rhs, solution);
    } // End of solve

References oomph::DistributableLinearAlgebraObject::build_distribution(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::LinearSolver::Enable_resolve, oomph::DampedJacobi< MATRIX >::extract_diagonal_entries(), oomph::DampedJacobi< MATRIX >::Matrix_can_be_deleted, oomph::DampedJacobi< MATRIX >::Matrix_pt, oomph::DampedJacobi< MATRIX >::Resolving, BiharmonicTestFunctions1::solution(), oomph::DampedJacobi< MATRIX >::solve_helper(), and oomph::Smoother::Use_as_smoother.

solve() [2/2]

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::solve ( Problem *const &  problem_pt, DoubleVector &  result  )

virtual

Use damped Jacobi iteration as an IterativeLinearSolver: This obtains the Jacobian matrix J and the residual vector r (needed for the Newton method) from the problem's get_jacobian function and returns the result of Jx=r.

/////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// Solver: Takes pointer to problem and returns the results vector which contains the solution of the linear system defined by the problem's fully assembled Jacobian and residual vector.

Implements oomph::LinearSolver.

  {
    // Reset the Use_as_smoother_flag as the solver is not being used
    // as a smoother
    Use_as_smoother = false;
 
    // Find the # of degrees of freedom (variables)
    unsigned n_dof = problem_pt->ndof();
 
    // Initialise timer
    double t_start = TimingHelpers::timer();
 
    // We're not re-solving
    Resolving = false;
 
    // Get rid of any previously stored data
    clean_up_memory();
 
    // Set up the distribution
    LinearAlgebraDistribution dist(problem_pt->communicator_pt(), n_dof, false);
 
    // Assign the distribution to the LinearSolver
    this->build_distribution(dist);
 
    // Allocate space for the Jacobian matrix in format specified
    // by template parameter
    Matrix_pt = new MATRIX;
 
    // Get the nonlinear residuals vector
    DoubleVector f;
 
    // Assign the Jacobian and the residuals vector
    problem_pt->get_jacobian(f, *Matrix_pt);
 
    // Extract the diagonal entries of the matrix and store them
    extract_diagonal_entries(Matrix_pt);
 
    // We've made the matrix, we can delete it...
    Matrix_can_be_deleted = true;
 
    // Doc time for setup
    double t_end = TimingHelpers::timer();
    Jacobian_setup_time = t_end - t_start;
 
    // If time documentation is enabled
    if (Doc_time)
    {
      oomph_info << "Time for setup of Jacobian [sec]: " << Jacobian_setup_time
                 << std::endl;
    }
 
    // Call linear algebra-style solver
    solve_helper(Matrix_pt, f, result);
 
    // Kill matrix unless it's still required for resolve
    if (!Enable_resolve) clean_up_memory();
  } // End of solve

References oomph::TerminateHelper::clean_up_memory(), oomph::Problem::communicator_pt(), f(), oomph::Problem::get_jacobian(), oomph::Problem::ndof(), oomph::oomph_info, and oomph::TimingHelpers::timer().

Referenced by oomph::DampedJacobi< MATRIX >::resolve().

solve_helper()

template<typename MATRIX >

void oomph::DampedJacobi< MATRIX >::solve_helper ( DoubleMatrixBase *const &  matrix_pt, const DoubleVector &  rhs, DoubleVector &  solution  )

private

This is where the actual work is done – different implementations for different matrix types.

Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system.

  {
    // Get number of dofs
    unsigned n_dof = rhs.nrow();
 
#ifdef PARANOID
    // Upcast the matrix to the appropriate type
    MATRIX* tmp_matrix_pt = dynamic_cast<MATRIX*>(matrix_pt);
 
    // PARANOID Run the self-tests to check the inputs are correct
    this->check_validity_of_solve_helper_inputs<MATRIX>(
      tmp_matrix_pt, rhs, solution, n_dof);
 
    // We don't need the pointer any more but we do still need the matrix
    // so just make tmp_matrix_pt a null pointer
    tmp_matrix_pt = 0;
#endif
 
    // Setup the solution if it is not
    if (!solution.distribution_pt()->built())
    {
      // Build the distribution of the solution vector if it hasn't been done
      // yet
      solution.build(this->distribution_pt(), 0.0);
    }
    // If the solution has already been set up
    else
    {
      // If we're inside the multigrid solver then as we traverse up the
      // hierarchy we use the smoother on the updated approximate solution.
      // As such, we should ONLY be resetting all the values to zero if
      // we're NOT inside the multigrid solver
      if (!Use_as_smoother)
      {
        // Initialise the vector with all entries set to zero
        solution.initialise(0.0);
      }
    } // if (!solution.distribution_pt()->built())
 
    // Initialise timer
    double t_start = TimingHelpers::timer();
 
    // Initial guess isn't necessarily zero (restricted solution from finer
    // grids) therefore x needs to be assigned values from the input.
    DoubleVector x(solution);
 
    // Create a vector to store the value of the constant term, omega*inv(D)*r
    DoubleVector constant_term(this->distribution_pt(), 0.0);
 
    // Calculate the constant term vector
    for (unsigned i = 0; i < n_dof; i++)
    {
      // Assign the i-th entry of constant_term
      constant_term[i] = Omega * Matrix_diagonal[i] * rhs[i];
    }
 
    // Create a vector to hold the residual. This will only be built if
    // we're not inside the multigrid solver
    DoubleVector local_residual;
 
    // Variable to store the 2-norm of the residual vector. Only used
    // if we are not working inside the MG solver
    double norm_res = 0.0;
 
    // Variables to hold the initial residual norm. Only used if we're
    // not inside the multigrid solver
    double norm_f = 0.0;
 
    // Initialise the value of Iterations
    Iterations = 0;
 
    // Calculate the residual only if we're not inside the multigrid solver
    if (!Use_as_smoother)
    {
      // Build the local residual vector
      local_residual.build(this->distribution_pt(), 0.0);
 
      // Calculate the residual vector
      matrix_pt->residual(x, rhs, local_residual);
 
      // Calculate the 2-norm
      norm_res = local_residual.norm();
 
      // Store the initial norm
      norm_f = norm_res;
 
      // If required will document convergence history to screen
      // or file (if stream is open)
      if (Doc_convergence_history)
      {
        if (!Output_file_stream.is_open())
        {
          oomph_info << Iterations << " " << norm_res << std::endl;
        }
        else
        {
          Output_file_stream << Iterations << " " << norm_res << std::endl;
        }
      } // if (Doc_convergence_history)
    } // if (!Use_as_smoother)
 
    // Create a temporary vector to store the value of A*e
    // on each iteration and another to store the residual
    // at the end of each iteration
    DoubleVector temp_vec(this->distribution_pt(), 0.0);
 
    // Outermost loop: Run up to Max_iter times (the iteration number)
    for (unsigned iter_num = 0; iter_num < Max_iter; iter_num++)
    {
      // Calculate A*e
      matrix_pt->multiply(x, temp_vec);
 
      // Loop over each degree of freedom and update
      // the current approximation
      for (unsigned idof = 0; idof < n_dof; idof++)
      {
        // Scale the idof'th entry of temp_vec
        // by omega/A(i,i)
        temp_vec[idof] *= Omega * Matrix_diagonal[idof];
      }
 
      // Update the value of e (in the system Ae=r)
      x += constant_term;
      x -= temp_vec;
 
      // Increment the value of Iterations
      Iterations++;
 
      // Calculate the residual only if we're not inside the multigrid solver
      if (!Use_as_smoother)
      {
        // Get residual
        matrix_pt->residual(x, rhs, local_residual);
 
        // Calculate the 2-norm of the residual r=b-Ax
        norm_res = local_residual.norm() / norm_f;
 
        // If required, this will document convergence history to
        // screen or file (if the stream is open)
        if (Doc_convergence_history)
        {
          if (!Output_file_stream.is_open())
          {
            oomph_info << Iterations << " " << norm_res << std::endl;
          }
          else
          {
            Output_file_stream << Iterations << " " << norm_res << std::endl;
          }
        } // if (Doc_convergence_history)
 
        // Check the tolerance only if the residual norm is being computed
        if (norm_res < Tolerance)
        {
          // Break out of the for-loop
          break;
        }
      } // if (!Use_as_smoother)
    } // for (unsigned iter_num=0;iter_num<Max_iter;iter_num++)
 
    // Calculate the residual only if we're not inside the multigrid solver
    if (!Use_as_smoother)
    {
      // If time documentation is enabled
      if (Doc_time)
      {
        oomph_info << "\nDamped Jacobi converged. Residual norm: " << norm_res
                   << "\nNumber of iterations to convergence: " << Iterations
                   << "\n"
                   << std::endl;
      }
    } // if (!Use_as_smoother)
 
    // Copy the solution into the solution vector
    solution = x;
 
    // Doc. time for solver
    double t_end = TimingHelpers::timer();
    Solution_time = t_end - t_start;
    if (Doc_time)
    {
      oomph_info << "Time for solve with damped Jacobi [sec]: " << Solution_time
                 << std::endl;
    }
 
    // If the solver failed to converge and the user asked for an error if
    // this happened
    if ((Iterations > Max_iter - 1) && (Throw_error_after_max_iter))
    {
      std::string error_message =
        "Solver failed to converge and you requested ";
      error_message += "an error on convergence failures.";
      throw OomphLibError(
        error_message, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
    }
  } // End of solve_helper

References oomph::DoubleVector::build(), i, Global_Variables::Iterations, oomph::BlackBoxFDNewtonSolver::Max_iter, oomph::DoubleMatrixBase::multiply(), oomph::DoubleVector::norm(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::SarahBL::Omega, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::DoubleMatrixBase::residual(), BiharmonicTestFunctions1::solution(), oomph::Global_string_for_annotation::string(), oomph::TimingHelpers::timer(), and plotDoE::x.

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

Member Data Documentation

Iterations

template<typename MATRIX >

unsigned oomph::DampedJacobi< MATRIX >::Iterations

private

Number of iterations taken.

Referenced by oomph::DampedJacobi< MATRIX >::iterations().

Matrix_can_be_deleted

template<typename MATRIX >

bool oomph::DampedJacobi< MATRIX >::Matrix_can_be_deleted

private

Boolean flag to indicate if the matrix pointed to be Matrix_pt can be deleted.

Referenced by oomph::DampedJacobi< MATRIX >::clean_up_memory(), oomph::DampedJacobi< MATRIX >::smoother_setup(), and oomph::DampedJacobi< MATRIX >::solve().

Matrix_diagonal

template<typename MATRIX >

Vector<double> oomph::DampedJacobi< MATRIX >::Matrix_diagonal

private

Vector containing the diagonal entries of A.

Referenced by oomph::DampedJacobi< MATRIX >::extract_diagonal_entries().

Matrix_pt

template<typename MATRIX >

MATRIX* oomph::DampedJacobi< MATRIX >::Matrix_pt

private

Pointer to the matrix.

Referenced by oomph::DampedJacobi< MATRIX >::clean_up_memory(), oomph::DampedJacobi< MATRIX >::extract_diagonal_entries(), oomph::DampedJacobi< MATRIX >::resolve(), oomph::DampedJacobi< MATRIX >::smoother_setup(), oomph::DampedJacobi< MATRIX >::smoother_solve(), and oomph::DampedJacobi< MATRIX >::solve().

Omega

template<typename MATRIX >

double oomph::DampedJacobi< MATRIX >::Omega

private

Damping factor.

Referenced by oomph::DampedJacobi< MATRIX >::DampedJacobi().

Resolving

template<typename MATRIX >

bool oomph::DampedJacobi< MATRIX >::Resolving

private

Boolean flag to indicate if the solve is done in re-solve mode, bypassing setup of matrix and preconditioner

Referenced by oomph::DampedJacobi< MATRIX >::resolve(), and oomph::DampedJacobi< MATRIX >::solve().

---

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

• iterative_linear_solver.h
• iterative_linear_solver.cc