oomph::GS< MATRIX > Class Template Reference

The Gauss Seidel method. More...

#include <iterative_linear_solver.h>

Inheritance diagram for oomph::GS< MATRIX >:

Public Member Functions
	GS ()
	Constructor. More...
virtual	~GS ()
	Destructor (cleanup storage) More...
	GS (const GS &)=delete
	Broken copy constructor. More...
void	operator= (const GS &)=delete
	Broken assignment operator. More...
void	disable_resolve ()
	Overload disable resolve so that it cleans up memory too. More...
void	smoother_setup (DoubleMatrixBase *matrix_pt)
	Set up the smoother for the matrix specified by the pointer. More...
void	smoother_solve (const DoubleVector &rhs, DoubleVector &result)
void	solve (Problem *const &problem_pt, DoubleVector &result)
void	solve (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &solution)
void	solve (DoubleMatrixBase *const &matrix_pt, const Vector< double > &rhs, Vector< double > &result)
void	resolve (const DoubleVector &rhs, DoubleVector &result)
double	preconditioner_setup_time () const
	Returns the time taken to set up the preconditioner. More...
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...
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	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)
	General interface to solve function. More...
void	clean_up_memory ()
	Cleanup data that's stored for resolve (if any has been stored) More...

Private Attributes
MATRIX *	Matrix_pt
	System matrix pointer in the format specified by the template argument. More...
unsigned	Iterations
	Number of iterations taken. More...
bool	Resolving
bool	Matrix_can_be_deleted

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::GS< MATRIX >

The Gauss Seidel method.

//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////

Constructor & Destructor Documentation

GS() [1/2]

template<typename MATRIX >

oomph::GS< MATRIX >::GS ( )

inline

Constructor.

      : Matrix_pt(0),
        Iterations(0),
        Resolving(false),
        Matrix_can_be_deleted(true)
    {
    }

~GS()

template<typename MATRIX >

virtual oomph::GS< MATRIX >::~GS ( )

inlinevirtual

Destructor (cleanup storage)

    {
      clean_up_memory();
    }

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

GS() [2/2]

template<typename MATRIX >

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

delete

Broken copy constructor.

Member Function Documentation

clean_up_memory()

template<typename MATRIX >

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

inlineprivatevirtual

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 it
      // delete the matrix and assign the pointer the value NULL
      if ((Matrix_pt != 0) && (Matrix_can_be_deleted))
      {
        // Destroy the matrix
        delete Matrix_pt;
 
        // Make it a null pointer
        Matrix_pt = 0;
      }
    } // End of clean_up_memory

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

Referenced by oomph::GS< MATRIX >::disable_resolve(), oomph::GS< CRDoubleMatrix >::disable_resolve(), oomph::GS< CRDoubleMatrix >::solve(), oomph::GS< MATRIX >::~GS(), and oomph::GS< CRDoubleMatrix >::~GS().

disable_resolve()

template<typename MATRIX >

void oomph::GS< MATRIX >::disable_resolve ( )

inlinevirtual

Overload disable resolve so that it cleans up memory too.

Reimplemented from oomph::LinearSolver.

    {
      LinearSolver::disable_resolve();
      clean_up_memory();
    } // End of disable_resolve

References oomph::GS< MATRIX >::clean_up_memory(), and oomph::LinearSolver::disable_resolve().

iterations()

template<typename MATRIX >

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

inlinevirtual

Number of iterations taken.

Implements oomph::IterativeLinearSolver.

    {
      return Iterations;
    } // End of iterations

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

operator=()

template<typename MATRIX >

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

delete

Broken assignment operator.

preconditioner_setup_time()

template<typename MATRIX >

double oomph::GS< MATRIX >::preconditioner_setup_time ( ) const

inlinevirtual

Returns the time taken to set up the preconditioner.

Reimplemented from oomph::IterativeLinearSolver.

    {
      throw OomphLibError(
        "Gauss Seidel is not a preconditionable iterative solver",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
      return 0;
    } // End of preconditioner_setup_time

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

resolve()

template<typename MATRIX >

void oomph::GS< 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::GS< MATRIX >::Matrix_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::GS< MATRIX >::Resolving, and oomph::GS< MATRIX >::solve().

smoother_setup()

template<typename MATRIX >

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

inlinevirtual

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

Implements oomph::Smoother.

    {
      // Assume the matrix has been passed in from the outside so we must
      // not delete it. This is needed to avoid pre- and post-smoothers
      // deleting the same matrix in the MG solver. If this was originally
      // set to TRUE then this will be sorted out in the other functions
      // from which this was called
      Matrix_can_be_deleted = false;
 
      // Upcast the input matrix to system matrix to the type MATRIX
      Matrix_pt = dynamic_cast<MATRIX*>(matrix_pt);
    } // End of smoother_setup

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

smoother_solve()

template<typename MATRIX >

void oomph::GS< MATRIX >::smoother_solve ( const DoubleVector &  rhs, DoubleVector &  result  )

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, result);
    } // End of smoother_setup

References oomph::GS< MATRIX >::Matrix_pt, oomph::GS< MATRIX >::solve_helper(), and oomph::Smoother::Use_as_smoother.

solve() [1/3]

template<typename MATRIX >

void oomph::GS< 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.

    {
      // Reset the Use_as_smoother_flag as 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);
      }
 
      // Matrix has been passed in from the outside so we must not delete it
      Matrix_can_be_deleted = false;
 
      // Call the helper function
      this->solve_helper(matrix_pt, rhs, solution);
    } // End of solve

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

solve() [2/3]

template<typename MATRIX >

void oomph::GS< MATRIX >::solve ( DoubleMatrixBase *const &  matrix_pt, const Vector< double > &  rhs, Vector< double > &  result  )

inlinevirtual

Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system Call the broken base-class version. If you want this, please implement it

Reimplemented from oomph::LinearSolver.

    {
      LinearSolver::solve(matrix_pt, rhs, result);
    } // End of solve

References oomph::LinearSolver::solve().

solve() [3/3]

template<typename MATRIX >

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

virtual

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.

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// 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);
 
    // 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
    this->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::GS< MATRIX >::resolve(), and oomph::GS< CRDoubleMatrix >::resolve().

solve_helper()

template<typename MATRIX >

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

private

General interface to solve function.

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
 
    // Set up the solution if it is not
    if (!solution.distribution_pt()->built())
    {
      // Build it!
      solution.build(this->distribution_pt(), 0.0);
    }
    // If the solution is already 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();
 
    // Copy the solution vector into x
    DoubleVector x(solution);
 
    // Create a vector to hold the residual. This will only be built if
    // we're not inside the multigrid solver
    DoubleVector current_residual;
 
    // Variable to hold the current residual norm. Only used if we're
    // not inside the multigrid 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 residual vector
      current_residual.build(this->distribution_pt(), 0.0);
 
      // Calculate the residual r=b-Ax
      matrix_pt->residual(x, rhs, current_residual);
 
      // Calculate the 2-norm of the residual vector
      norm_res = current_residual.norm();
 
      // Store the initial norm
      norm_f = norm_res;
 
      // If required, document the convergence history to screen or file (if
      // the output stream open)
      if (Doc_convergence_history)
      {
        // If the output file stream isn't open
        if (!Output_file_stream.is_open())
        {
          // Output the result to screen
          oomph_info << Iterations << " " << norm_res << std::endl;
        }
        // If the output file stream is open
        else
        {
          // Document the result to file
          Output_file_stream << Iterations << " " << norm_res << std::endl;
        }
      } // if (Doc_convergence_history)
    } // if (!Use_as_smoother)
 
    // Start of the main GS loop: run up to Max_iter times
    for (unsigned iter_num = 0; iter_num < Max_iter; iter_num++)
    {
      // Loop over rows
      for (unsigned i = 0; i < n_dof; i++)
      {
        double dummy = rhs[i];
        for (unsigned j = 0; j < i; j++)
        {
          dummy -= (*(matrix_pt))(i, j) * x[j];
        }
        for (unsigned j = (i + 1); j < n_dof; j++)
        {
          dummy -= (*(matrix_pt))(i, j) * x[j];
        }
        x[i] = dummy / (*(matrix_pt))(i, i);
      } // for(unsigned i=0;i<n_dof;i++)
 
      // 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, current_residual);
 
        // Calculate the relative residual norm (i.e.
        // \frac{\|r_{i}\|}{\|r_{0}\|})
        norm_res = current_residual.norm() / norm_f;
 
        // If required will document convergence history to screen or file (if
        // stream 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 << "\nGS converged. Residual norm: " << norm_res
                   << "\nNumber of iterations to convergence: " << Iterations
                   << "\n"
                   << std::endl;
      }
    } // if (!Use_as_smoother)
 
    // Copy result into result
    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 GS [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, j, oomph::BlackBoxFDNewtonSolver::Max_iter, oomph::DoubleVector::norm(), oomph::DistributableLinearAlgebraObject::nrow(), 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::GS< MATRIX >::smoother_solve(), oomph::GS< CRDoubleMatrix >::smoother_solve(), oomph::GS< MATRIX >::solve(), and oomph::GS< CRDoubleMatrix >::solve().

Member Data Documentation

Iterations

template<typename MATRIX >

unsigned oomph::GS< MATRIX >::Iterations

private

Number of iterations taken.

Referenced by oomph::GS< MATRIX >::iterations(), oomph::GS< CRDoubleMatrix >::iterations(), and oomph::GS< CRDoubleMatrix >::solve_helper().

Matrix_can_be_deleted

template<typename MATRIX >

bool oomph::GS< MATRIX >::Matrix_can_be_deleted

private

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

Referenced by oomph::GS< MATRIX >::clean_up_memory(), oomph::GS< CRDoubleMatrix >::clean_up_memory(), oomph::GS< CRDoubleMatrix >::setup_helper(), oomph::GS< MATRIX >::smoother_setup(), oomph::GS< CRDoubleMatrix >::smoother_setup(), oomph::GS< MATRIX >::solve(), and oomph::GS< CRDoubleMatrix >::solve().

Matrix_pt

template<typename MATRIX >

MATRIX* oomph::GS< MATRIX >::Matrix_pt

private

System matrix pointer in the format specified by the template argument.

Referenced by oomph::GS< MATRIX >::clean_up_memory(), oomph::GS< CRDoubleMatrix >::clean_up_memory(), oomph::GS< MATRIX >::resolve(), oomph::GS< CRDoubleMatrix >::resolve(), oomph::GS< CRDoubleMatrix >::setup_helper(), oomph::GS< MATRIX >::smoother_setup(), oomph::GS< MATRIX >::smoother_solve(), oomph::GS< CRDoubleMatrix >::smoother_solve(), oomph::GS< MATRIX >::solve(), and oomph::GS< CRDoubleMatrix >::solve().

Resolving

template<typename MATRIX >

bool oomph::GS< 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::GS< MATRIX >::resolve(), oomph::GS< CRDoubleMatrix >::resolve(), oomph::GS< MATRIX >::solve(), and oomph::GS< CRDoubleMatrix >::solve().

---

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

• iterative_linear_solver.h
• iterative_linear_solver.cc