oomph::HypreSolver Class Reference

#include <hypre_solver.h>

Inheritance diagram for oomph::HypreSolver:

Public Member Functions
	HypreSolver ()
	Constructor. More...
	~HypreSolver ()
	Empty destructor. More...
	HypreSolver (const HypreSolver &)=delete
	Broken copy constructor. More...
void	operator= (const HypreSolver &)=delete
	Broken assignment operator. More...
void	disable_resolve ()
unsigned &	max_iter ()
	Access function to Max_iter. More...
double &	tolerance ()
	Access function to Tolerance. More...
unsigned &	hypre_method ()
	Access function to Hypre_method flag – specified via enumeration. More...
unsigned &	internal_preconditioner ()
void	amg_using_simple_smoothing ()
unsigned &	amg_simple_smoother ()
	Access function to AMG_simple_smoother flag. More...
void	amg_using_complex_smoothing ()
unsigned &	amg_complex_smoother ()
	Access function to AMG_complex_smoother flag. More...
unsigned &	amg_print_level ()
	Access function to AMG_print_level. More...
unsigned &	amg_smoother_iterations ()
	Access function to AMG_smoother_iterations. More...
unsigned &	amg_coarsening ()
	Access function to AMG_coarsening flag. More...
unsigned &	amg_max_levels ()
	Access function to AMG_max_levels. More...
double &	amg_damping ()
	Access function to AMG_damping parameter. More...
double &	amg_strength ()
	Access function to AMG_strength. More...
double &	amg_max_row_sum ()
	Access function to AMG_max_row_sum. More...
double &	amg_truncation ()
	Access function to AMG_truncation. More...
int &	parasails_symmetry ()
	Access function to ParaSails symmetry flag. More...
int &	parasails_nlevel ()
	Access function to ParaSails nlevel parameter. More...
double &	parasails_thresh ()
	Access function to ParaSails thresh parameter. More...
double &	parasails_filter ()
	Access function to ParaSails filter parameter. More...
double &	euclid_droptol ()
	Access function to Euclid drop tolerance parameter. More...
int &	euclid_level ()
void	enable_euclid_rowScale ()
	Enable euclid rowScaling. More...
void	disable_euclid_rowScale ()
	Disable euclid row scaling. More...
void	enable_euclid_using_BJ ()
void	disable_euclid_using_BJ ()
void	euclid_using_ILUK ()
void	euclid_using_ILUT ()
unsigned &	euclid_print_level ()
unsigned &	krylov_print_level ()
	Access function to Krylov_print_level. More...
void	enable_delete_matrix ()
void	disable_delete_matrix ()
void	solve (Problem *const &problem_pt, DoubleVector &solution)
void	solve (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &solution)
void	resolve (const DoubleVector &rhs, DoubleVector &solution)
void	clean_up_memory ()
	Function deletes all solver data. More...
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 (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 double	jacobian_setup_time () const
virtual double	linear_solver_solution_time () const
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)
Public Member Functions inherited from oomph::HypreInterface
	HypreInterface ()
	Constructor. More...
	~HypreInterface ()
	Destructor. More...
	HypreInterface (const HypreInterface &)=delete
	Broken copy constructor. More...
void	operator= (const HypreInterface &)=delete
	Broken assignment operator. More...
void	enable_hypre_error_messages ()
	Turn on the hypre error messages. More...
void	disable_hypre_error_messages ()
	Turn off hypre error messages. More...
unsigned	existing_solver ()
	Function to return value of which solver (if any) is currently stored. More...
unsigned	existing_preconditioner ()
	Function return value of which preconditioner (if any) is stored. More...

Private Attributes
bool	Delete_matrix

Additional Inherited Members
Public Types inherited from oomph::HypreInterface
enum	Hypre_method_types {   CG , GMRES , BiCGStab , BoomerAMG ,   Euclid , ParaSails , None }
Public Attributes inherited from oomph::HypreInterface
bool	AMGEuclidSmoother_use_block_jacobi
bool	AMGEuclidSmoother_use_row_scaling
bool	AMGEuclidSmoother_use_ilut
unsigned	AMGEuclidSmoother_level
double	AMGEuclidSmoother_drop_tol
unsigned	AMGEuclidSmoother_print_level
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()
Protected Member Functions inherited from oomph::HypreInterface
void	hypre_clean_up_memory ()
	Function deletes all solver data. More...
void	hypre_matrix_setup (CRDoubleMatrix *matrix_pt)
void	hypre_solver_setup ()
void	hypre_solve (const DoubleVector &rhs, DoubleVector &solution)
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
Protected Attributes inherited from oomph::HypreInterface
bool	Output_info
	Flag is true to output info and results of timings. More...
unsigned	Max_iter
	Maximum number of iterations used in solver. More...
double	Tolerance
	Tolerance used to terminate solver. More...
unsigned	Hypre_method
	Hypre method flag. Valid values are specified in enumeration. More...
unsigned	Internal_preconditioner
unsigned	AMG_print_level
unsigned	AMG_max_levels
	Maximum number of levels used in AMG. More...
double	AMG_max_row_sum
	Parameter to identify diagonally dominant parts of the matrix in AMG. More...
bool	AMG_using_simple_smoothing
unsigned	AMG_simple_smoother
unsigned	AMG_complex_smoother
unsigned	AMG_smoother_iterations
	The number of smoother iterations to apply. More...
double	AMG_damping
	Damping factor for BoomerAMG smoothed Jacobi or hybrid SOR. More...
double	AMG_strength
	Connection strength threshold parameter for BoomerAMG. More...
double	AMG_truncation
	Interpolation truncation factor for BoomerAMG. More...
unsigned	AMG_coarsening
int	ParaSails_symmetry
int	ParaSails_nlevel
	ParaSails nlevel parameter. More...
double	ParaSails_thresh
	ParaSails thresh parameter. More...
double	ParaSails_filter
	ParaSails filter parameter. More...
double	Euclid_droptol
	Euclid drop tolerance for ILU(k) and ILUT factorization. More...
bool	Euclid_rowScale
	Flag to switch on Euclid row scaling. More...
bool	Euclid_using_ILUT
	Flag to determine if ILUT (if true) or ILU(k) is used in Euclid. More...
bool	Euclid_using_BJ
	Flag to determine if Block Jacobi is used instead of PILU. More...
int	Euclid_level
	Euclid level parameter for ILU(k) factorization. More...
unsigned	Euclid_print_level
unsigned	Krylov_print_level
bool	Hypre_error_messages
bool	Delete_input_data

Detailed Description

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// An LinearSolver class using the suite of Hypre solvers to allow

BoomerAMG (AMG), CG, GMRES or BiCGStab

to be used for LinearSolver::solve(...) or LinearSolver::resolve(...).

The Krylov subspace solvers (CG, GMRES and BiCGStab) may be preconditioned using:

BoomerAMG, Euclid or ParaSails

By default GMRES without preconditioning is used.

Constructor & Destructor Documentation

HypreSolver() [1/2]

oomph::HypreSolver::HypreSolver ( )

inline

Constructor.

    {
      // Hypre copies matrix data from oomph-lib's CRDoubleMatrix
      // and Distributed CRDoubleMatrix into its own data structures,
      // doubling the memory requirements for the matrix.
      // As far as the Hypre solvers are concerned the oomph-lib matrix
      // is no longer required and could be deleted to save memory.
      // However, this will not be the expected behaviour and therefore
      // needs to be requested explicitly by the user by changing this
      // flag from false (its default) to true.
      Delete_matrix = false;
 
      // Do we want to output results of timings?
      Doc_time = true;
    }

References Delete_matrix, and oomph::LinearSolver::Doc_time.

~HypreSolver()

oomph::HypreSolver::~HypreSolver ( )

inline

Empty destructor.

{}

HypreSolver() [2/2]

oomph::HypreSolver::HypreSolver ( const HypreSolver &  )

delete

Broken copy constructor.

Member Function Documentation

amg_coarsening()

unsigned& oomph::HypreSolver::amg_coarsening ( )

inline

Access function to AMG_coarsening flag.

    {
      return AMG_coarsening;
    }

References oomph::HypreInterface::AMG_coarsening.

amg_complex_smoother()

unsigned& oomph::HypreSolver::amg_complex_smoother ( )

inline

Access function to AMG_complex_smoother flag.

    {
      return AMG_complex_smoother;
    }

References oomph::HypreInterface::AMG_complex_smoother.

amg_damping()

double& oomph::HypreSolver::amg_damping ( )

inline

Access function to AMG_damping parameter.

    {
      return AMG_damping;
    }

References oomph::HypreInterface::AMG_damping.

amg_max_levels()

unsigned& oomph::HypreSolver::amg_max_levels ( )

inline

Access function to AMG_max_levels.

    {
      return AMG_max_levels;
    }

References oomph::HypreInterface::AMG_max_levels.

amg_max_row_sum()

double& oomph::HypreSolver::amg_max_row_sum ( )

inline

Access function to AMG_max_row_sum.

    {
      return AMG_max_row_sum;
    }

References oomph::HypreInterface::AMG_max_row_sum.

amg_print_level()

unsigned& oomph::HypreSolver::amg_print_level ( )

inline

Access function to AMG_print_level.

    {
      return AMG_print_level;
    }

References oomph::HypreInterface::AMG_print_level.

Referenced by main(), and TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

amg_simple_smoother()

unsigned& oomph::HypreSolver::amg_simple_smoother ( )

inline

Access function to AMG_simple_smoother flag.

    {
      return AMG_simple_smoother;
    }

References oomph::HypreInterface::AMG_simple_smoother.

Referenced by main(), and TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

amg_smoother_iterations()

unsigned& oomph::HypreSolver::amg_smoother_iterations ( )

inline

Access function to AMG_smoother_iterations.

    {
      return AMG_smoother_iterations;
    }

References oomph::HypreInterface::AMG_smoother_iterations.

amg_strength()

double& oomph::HypreSolver::amg_strength ( )

inline

Access function to AMG_strength.

    {
      return AMG_strength;
    }

References oomph::HypreInterface::AMG_strength.

amg_truncation()

double& oomph::HypreSolver::amg_truncation ( )

inline

Access function to AMG_truncation.

    {
      return AMG_truncation;
    }

References oomph::HypreInterface::AMG_truncation.

amg_using_complex_smoothing()

void oomph::HypreSolver::amg_using_complex_smoothing ( )

inline

Function to select use of 'complex' AMG smoothers as controlled by AMG_complex_smoother flag

    {
      AMG_using_simple_smoothing = false;
    }

References oomph::HypreInterface::AMG_using_simple_smoothing.

amg_using_simple_smoothing()

void oomph::HypreSolver::amg_using_simple_smoothing ( )

inline

Function to select use of 'simple' AMG smoothers as controlled by AMG_simple_smoother flag

    {
      AMG_using_simple_smoothing = true;
    }

References oomph::HypreInterface::AMG_using_simple_smoothing.

clean_up_memory()

void oomph::HypreSolver::clean_up_memory ( )

virtual

Function deletes all solver data.

clean_up_memory() deletes any existing solver data

Reimplemented from oomph::LinearSolver.

  {
    hypre_clean_up_memory();
  }

References oomph::HypreInterface::hypre_clean_up_memory().

Referenced by disable_resolve(), and solve().

disable_delete_matrix()

void oomph::HypreSolver::disable_delete_matrix ( )

inline

Hypre copies matrix data from oomph-lib's CRDoubleMatrix or DistributedCRDoubleMatrix into its own data structures, doubling the memory requirements for the matrix. Calling this function ensures that the matrix is not deleted.

    {
      Delete_matrix = false;
    }

References Delete_matrix.

disable_euclid_rowScale()

void oomph::HypreSolver::disable_euclid_rowScale ( )

inline

Disable euclid row scaling.

    {
      Euclid_rowScale = false;
    }

References oomph::HypreInterface::Euclid_rowScale.

disable_euclid_using_BJ()

void oomph::HypreSolver::disable_euclid_using_BJ ( )

inline

Disable use of Block Jacobi, so PILU will be used

    {
      Euclid_using_BJ = false;
    }

References oomph::HypreInterface::Euclid_using_BJ.

disable_resolve()

void oomph::HypreSolver::disable_resolve ( )

inlinevirtual

Disable resolve function (overloads the LinearSolver disable_resolve function).

Reimplemented from oomph::LinearSolver.

    {
      Enable_resolve = false;
      clean_up_memory();
    }

References clean_up_memory(), and oomph::LinearSolver::Enable_resolve.

enable_delete_matrix()

void oomph::HypreSolver::enable_delete_matrix ( )

inline

Hypre copies matrix data from oomph-lib's CRDoubleMatrix or DistributedCRDoubleMatrix into its own data structures, doubling the memory requirements for the matrix. As far as the Hypre solvers are concerned the oomph-lib matrix is no longer required and could be deleted to save memory. However, this will not be the expected behaviour and therefore needs to be requested explicitly by the user by calling this function which changes the flag from false (its default) to true.

    {
      Delete_matrix = true;
    }

References Delete_matrix.

enable_euclid_rowScale()

void oomph::HypreSolver::enable_euclid_rowScale ( )

inline

Enable euclid rowScaling.

    {
      Euclid_rowScale = true;
    }

References oomph::HypreInterface::Euclid_rowScale.

enable_euclid_using_BJ()

void oomph::HypreSolver::enable_euclid_using_BJ ( )

inline

Enable use of Block Jacobi as opposed to PILU

    {
      Euclid_using_BJ = true;
    }

References oomph::HypreInterface::Euclid_using_BJ.

euclid_droptol()

double& oomph::HypreSolver::euclid_droptol ( )

inline

Access function to Euclid drop tolerance parameter.

    {
      return Euclid_droptol;
    }

References oomph::HypreInterface::Euclid_droptol.

euclid_level()

int& oomph::HypreSolver::euclid_level ( )

inline

Access function to Euclid level parameter for ILU(k) factorization

    {
      return Euclid_level;
    }

References oomph::HypreInterface::Euclid_level.

euclid_print_level()

unsigned& oomph::HypreSolver::euclid_print_level ( )

inline

Function to set the level of printing from Euclid when the Euclid destructor is called 0: no printing (default) 1: prints summary of runtime settings and timings 2: as 1 plus prints memory usage

    {
      return Euclid_print_level;
    }

References oomph::HypreInterface::Euclid_print_level.

euclid_using_ILUK()

void oomph::HypreSolver::euclid_using_ILUK ( )

inline

Function to switch on ILU(k) factorization for Euclid (default is ILU(k) factorization)

    {
      Euclid_using_ILUT = false;
    }

References oomph::HypreInterface::Euclid_using_ILUT.

euclid_using_ILUT()

void oomph::HypreSolver::euclid_using_ILUT ( )

inline

Function to switch on ILUT factorization for Euclid (default is ILU(k) factorization)

    {
      Euclid_using_ILUT = true;
    }

References oomph::HypreInterface::Euclid_using_ILUT.

hypre_method()

unsigned& oomph::HypreSolver::hypre_method ( )

inline

Access function to Hypre_method flag – specified via enumeration.

    {
      return Hypre_method;
    }

References oomph::HypreInterface::Hypre_method.

Referenced by main(), and TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

internal_preconditioner()

unsigned& oomph::HypreSolver::internal_preconditioner ( )

inline

Access function to Internal_preconditioner flag – specified via enumeration.

    {
      return Internal_preconditioner;
    }

References oomph::HypreInterface::Internal_preconditioner.

Referenced by main().

krylov_print_level()

unsigned& oomph::HypreSolver::krylov_print_level ( )

inline

Access function to Krylov_print_level.

    {
      return Krylov_print_level;
    }

References oomph::HypreInterface::Krylov_print_level.

Referenced by main(), and TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

max_iter()

unsigned& oomph::HypreSolver::max_iter ( )

inline

Access function to Max_iter.

    {
      return Max_iter;
    }

References oomph::HypreInterface::Max_iter.

Referenced by main(), and TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

operator=()

void oomph::HypreSolver::operator= ( const HypreSolver &  )

delete

Broken assignment operator.

parasails_filter()

double& oomph::HypreSolver::parasails_filter ( )

inline

Access function to ParaSails filter parameter.

    {
      return ParaSails_filter;
    }

References oomph::HypreInterface::ParaSails_filter.

parasails_nlevel()

int& oomph::HypreSolver::parasails_nlevel ( )

inline

Access function to ParaSails nlevel parameter.

    {
      return ParaSails_nlevel;
    }

References oomph::HypreInterface::ParaSails_nlevel.

parasails_symmetry()

int& oomph::HypreSolver::parasails_symmetry ( )

inline

Access function to ParaSails symmetry flag.

    {
      return ParaSails_symmetry;
    }

References oomph::HypreInterface::ParaSails_symmetry.

parasails_thresh()

double& oomph::HypreSolver::parasails_thresh ( )

inline

Access function to ParaSails thresh parameter.

    {
      return ParaSails_thresh;
    }

References oomph::HypreInterface::ParaSails_thresh.

resolve()

void oomph::HypreSolver::resolve ( const DoubleVector &  rhs, DoubleVector &  solution  )

virtual

Function to resolve a linear system using the existing solver data, allowing a solve with a new right hand side vector. This function must be used after a call to solve(...) with enable_resolve set to true.

Resolve performs a linear solve using current solver data (if such data exists).

Reimplemented from oomph::LinearSolver.

  {
#ifdef PARANOID
    // check solver data exists
    if (existing_solver() == None)
    {
      std::ostringstream error_message;
      error_message << "resolve(...) requires that solver data has been "
                    << "set up by a previous call to solve(...) after "
                    << "a call to enable_resolve()" << std::endl;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
    // check that rhs has the same distribution as the matrix (now stored
    // in Distribution_pt)
    if (*this->distribution_pt() != *rhs.distribution_pt())
    {
      std::ostringstream error_message;
      error_message << "The distribution of the rhs vector and the matrix "
                    << " must be the same" << std::endl;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
    // if the solution is setup make sure it has the same distribution as
    // the matrix as well
    if (solution.built())
    {
      if (*this->distribution_pt() != *solution.distribution_pt())
      {
        std::ostringstream error_message;
        error_message << "The distribution of the solution vector is setup "
                      << "there it must be the same as the matrix."
                      << std::endl;
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
 
    // Set Output_info flag for HypreInterface
    Output_info = Doc_time;
 
    // solve
    hypre_solve(rhs, solution);
 
    // Note: never delete solver data as the preconditioner is typically
    // called repeatedly.
  }

References oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::LinearSolver::Doc_time, oomph::HypreInterface::existing_solver(), oomph::HypreInterface::hypre_solve(), oomph::HypreInterface::None, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::HypreInterface::Output_info, and BiharmonicTestFunctions1::solution().

solve() [1/2]

void oomph::HypreSolver::solve ( DoubleMatrixBase *const &  matrix_pt, const DoubleVector &  rhs, DoubleVector &  solution  )

virtual

Function to solve the linear system defined by matrix_pt and rhs. This function will delete any existing internal data and generate a new Hypre solver. Note: The matrix has to be of type CRDoubleMatrix or Distributed CRDoubleMatrix. Note: Hypre copies matrix data from oomph-lib's CRDoubleMatrix or DistributedCRDoubleMatrix into its own data structures, doubling the memory requirements for the matrix. As far as the Hypre solvers are concerned, the oomph-lib matrix is no longer required and could be deleted to save memory. However, this will not be the expected behaviour and therefore needs to be requested explicitly by the user by calling the enable_delete_matrix() function.

Uses HypreInterface::hypre_solve(...) to solve the linear system for a CRDoubleMatrix or a DistributedCRDoubleMatrix. In the latter case, the rhs needs to be distributed too, i.e. the length of the rhs vector must be equal to the number of rows stored locally. Note: the returned solution vector is never distributed, i.e. all processors hold all values

Reimplemented from oomph::LinearSolver.

  {
#ifdef PARANOID
    // check the matrix is square
    if (matrix_pt->nrow() != matrix_pt->ncol())
    {
      std::ostringstream error_message;
      error_message << "HypreSolver require a square matrix. "
                    << "Matrix is " << matrix_pt->nrow() << " by "
                    << matrix_pt->ncol() << std::endl;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Set Output_time flag for HypreInterface
    Output_info = Doc_time;
 
    // Clean up existing solver data
    clean_up_memory();
 
    // Set flag to decide if oomphlib matrix can be deleted
    // (Recall that Delete_matrix defaults to false).
    Delete_input_data = Delete_matrix;
 
    // Try cast to a CRDoubleMatrix
    CRDoubleMatrix* cr_matrix_pt = dynamic_cast<CRDoubleMatrix*>(matrix_pt);
 
    // If cast successful set things up for a serial solve
    if (cr_matrix_pt)
    {
      // rebuild the distribution
      this->build_distribution(cr_matrix_pt->distribution_pt());
 
#ifdef PARANOID
      // check that rhs has the same distribution as the matrix (now stored
      // in Distribution_pt)
      if (*this->distribution_pt() != *rhs.distribution_pt())
      {
        std::ostringstream error_message;
        error_message << "The distribution of the rhs vector and the matrix "
                      << " must be the same" << std::endl;
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      // if the solution is setup make sure it has the same distribution as
      // the matrix as well
      if (solution.built())
      {
        if (*this->distribution_pt() != *solution.distribution_pt())
        {
          std::ostringstream error_message;
          error_message << "The distribution of the solution vector is setup "
                        << "there it must be the same as the matrix."
                        << std::endl;
          throw OomphLibError(error_message.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
      }
#endif
 
      hypre_matrix_setup(cr_matrix_pt);
    }
    else
    {
#ifdef PARANOID
      std::ostringstream error_message;
      error_message << "HypreSolver only work with "
                    << "CRDoubleMatrix matrices" << std::endl;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
#endif
    }
 
    // call hypre_setup to generate Hypre matrix and linear solver data
    hypre_solver_setup();
 
    // perform hypre_solve
    hypre_solve(rhs, solution);
 
    // delete solver data if required
    if (!Enable_resolve)
    {
      clean_up_memory();
    }
  }

References oomph::DistributableLinearAlgebraObject::build_distribution(), clean_up_memory(), oomph::HypreInterface::Delete_input_data, Delete_matrix, oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::LinearSolver::Doc_time, oomph::LinearSolver::Enable_resolve, oomph::HypreInterface::hypre_matrix_setup(), oomph::HypreInterface::hypre_solve(), oomph::HypreInterface::hypre_solver_setup(), oomph::DoubleMatrixBase::ncol(), oomph::DoubleMatrixBase::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::HypreInterface::Output_info, and BiharmonicTestFunctions1::solution().

solve() [2/2]

void oomph::HypreSolver::solve ( Problem *const &  problem_pt, DoubleVector &  solution  )

virtual

Function which uses problem_pt's get_jacobian(...) function to generate a linear system which is then solved. This function deletes any existing internal data and then generates a new Hypre solver.

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Problem-based solve function to generate the Jacobian matrix and residual vector and use HypreInterface::hypre_solver_setup(...) and HypreInterface::hypre_solve(...) to solve the linear system. This function will delete any existing data. Note: the returned solution vector is NOT distributed, i.e. all processors hold all values because this is what the Newton solver requires.

Implements oomph::LinearSolver.

  {
    double t_start = TimingHelpers::timer();
 
    // Set Output_time flag for HypreInterface
    Output_info = Doc_time;
 
    // Delete any existing solver data
    clean_up_memory();
 
    // Set flag to allow deletion of the oomphlib Jacobian matrix
    // (we're in control)
    Delete_input_data = true;
 
    // Get oomph-lib Jacobian matrix and residual vector
    DoubleVector residual;
    CRDoubleMatrix* matrix = new CRDoubleMatrix;
    problem_pt->get_jacobian(residual, *matrix);
 
    // Output times
    if (Doc_time)
    {
      oomph_info << "Time to generate Jacobian and residual [s] : ";
      double t_end = TimingHelpers::timer();
      oomph_info << t_end - t_start << std::endl;
    }
 
    // generate hypre matrix
    hypre_matrix_setup(matrix);
 
    // call hypre_solver_setup to generate linear solver data
    hypre_solver_setup();
 
    // perform hypre_solve
    hypre_solve(residual, solution);
 
    // delete solver data if required
    if (!Enable_resolve)
    {
      clean_up_memory();
    }
  }

References clean_up_memory(), oomph::HypreInterface::Delete_input_data, oomph::LinearSolver::Doc_time, oomph::LinearSolver::Enable_resolve, oomph::Problem::get_jacobian(), oomph::HypreInterface::hypre_matrix_setup(), oomph::HypreInterface::hypre_solve(), oomph::HypreInterface::hypre_solver_setup(), matrix(), oomph::oomph_info, oomph::HypreInterface::Output_info, BiharmonicTestFunctions1::solution(), and oomph::TimingHelpers::timer().

tolerance()

double& oomph::HypreSolver::tolerance ( )

inline

Access function to Tolerance.

    {
      return Tolerance;
    }

References oomph::HypreInterface::Tolerance.

Referenced by main(), and TetmeshPoissonProblem< ELEMENT >::TetmeshPoissonProblem().

Member Data Documentation

Delete_matrix

bool oomph::HypreSolver::Delete_matrix

private

Hypre copies matrix data from oomph-lib's CRDoubleMatrix or DistributedCRDoubleMatrix into its own data structures, doubling the memory requirements for the matrix. As far as the Hypre solvers are concerned the oomph-lib matrix is no longer required and could be deleted to save memory. However, this will not be the expected behaviour and therefore needs to be requested explicitly by the user by changing this flag from false (its default) to true.

Referenced by disable_delete_matrix(), enable_delete_matrix(), HypreSolver(), and solve().

---

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

• hypre_solver.h
• hypre_solver.cc