oomph::HypreInterface Class Reference

#include <hypre_solver.h>

Inheritance diagram for oomph::HypreInterface:

Public Types
enum	Hypre_method_types {   CG , GMRES , BiCGStab , BoomerAMG ,   Euclid , ParaSails , None }

Public Member Functions
	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...

Public Attributes
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
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
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

Private Attributes
bool	Delete_matrix
HYPRE_IJMatrix	Matrix_ij
HYPRE_ParCSRMatrix	Matrix_par
HYPRE_Solver	Solver
HYPRE_Solver	Preconditioner
unsigned	Existing_solver
	Used to keep track of which solver (if any) is currently stored. More...
unsigned	Existing_preconditioner
	Used to keep track of which preconditioner (if any) is currently stored. More...
LinearAlgebraDistribution *	Hypre_distribution_pt
	the distribution for this helpers- More...

Detailed Description

An interface class to the suite of Hypre solvers and preconditioners to allow use of:

BoomerAMG (AMG), CG, GMRES or BiCGStab, Euclid (ILU) or ParaSails (Approximate inverse)

Hypre's Krylov subspace solvers (CG, GMRES and BiCGStab) may be preconditioned using:

BoomerAMG, Euclid or ParaSails

Member Enumeration Documentation

Hypre_method_types

enum oomph::HypreInterface::Hypre_method_types

Enumerated flag to define which Hypre methods are used CAREFUL: DON'T CHANGE THE ORDER OF THESE!

Enumerator
CG
GMRES
BiCGStab
BoomerAMG
Euclid
ParaSails
None

    {
      CG,
      GMRES,
      BiCGStab,
      BoomerAMG,
      Euclid,
      ParaSails,
      None
    };

Constructor & Destructor Documentation

HypreInterface() [1/2]

oomph::HypreInterface::HypreInterface ( )

inline

Constructor.

    {
#ifdef PARANOID
#ifndef HYPRE_SEQUENTIAL
      // For the MPI version of Hypre, check MPI_Helpers::setup has been called
      if (MPI_Helpers::mpi_has_been_initialised() == false)
      {
        std::ostringstream error_message;
        error_message << "When using the MPI version of Hypre please first\n"
                      << "call function MPI_Helpers::setup()\n";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
#endif
 
      // setup the distribution
      Hypre_distribution_pt = new LinearAlgebraDistribution();
 
      // These keep track of which solver and preconditioner
      // (if any) currently exist
      Existing_solver = None;
      Existing_preconditioner = None;
 
      // Do we want to output info and results of timings?
      Output_info = true;
 
      // General control paramaters
      Tolerance = 1e-10;
      Max_iter = 100;
      Hypre_method = GMRES;
      Internal_preconditioner = None;
 
      // Default AMG control parameters -- these seem OK;
      // see hypre documenation for details.
      AMG_using_simple_smoothing = true;
      if (MPI_Helpers::communicator_pt()->nproc() > 1)
      {
        // Jacobi in parallel
        AMG_simple_smoother = 0;
      }
      else
      {
        // Gauss Seidel in serial
        AMG_simple_smoother = 1;
      }
      AMG_complex_smoother = 6;
      AMG_smoother_iterations = 2;
      AMG_damping = 1.0;
      AMG_strength = HypreHelpers::AMG_strength; // 0.25;
      AMG_truncation = HypreHelpers::AMG_truncation; // 0.0;
      AMG_coarsening = HypreHelpers::AMG_coarsening; // 0
      AMG_max_levels = 100;
      AMG_max_row_sum = 1.0;
      AMG_print_level = 0;
 
      // Parameters for using Euclicd as an AMG smoother (defaults copied
      // from the normal defaults listed in the manual).
      AMGEuclidSmoother_use_block_jacobi = false;
      AMGEuclidSmoother_use_row_scaling = false;
      AMGEuclidSmoother_use_ilut = false;
      AMGEuclidSmoother_level = 1;
      AMGEuclidSmoother_drop_tol = 0; // No dropping
      AMGEuclidSmoother_print_level = 0;
 
      // Print level for CG, GMRES and BiCGStab
      Krylov_print_level = 0;
 
      // Set ParaSails default values
      ParaSails_symmetry = 2;
      ParaSails_nlevel = 1;
      ParaSails_thresh = 0.1;
      ParaSails_filter = 0.1;
 
      // Set Euclid default values
      Euclid_droptol = 0.0;
      Euclid_rowScale = false;
      Euclid_using_ILUT = false;
      Euclid_using_BJ = false;
      Euclid_level = 1;
      Euclid_print_level = 0;
 
      // Set to true to periodically check the hypre error flag
      // and output any messages
      Hypre_error_messages = false;
    }

References oomph::HypreHelpers::AMG_coarsening, AMG_coarsening, AMG_complex_smoother, AMG_damping, AMG_max_levels, AMG_max_row_sum, AMG_print_level, AMG_simple_smoother, AMG_smoother_iterations, oomph::HypreHelpers::AMG_strength, AMG_strength, oomph::HypreHelpers::AMG_truncation, AMG_truncation, AMG_using_simple_smoothing, AMGEuclidSmoother_drop_tol, AMGEuclidSmoother_level, AMGEuclidSmoother_print_level, AMGEuclidSmoother_use_block_jacobi, AMGEuclidSmoother_use_ilut, AMGEuclidSmoother_use_row_scaling, oomph::MPI_Helpers::communicator_pt(), e(), Euclid_droptol, Euclid_level, Euclid_print_level, Euclid_rowScale, Euclid_using_BJ, Euclid_using_ILUT, Existing_preconditioner, Existing_solver, GMRES, Hypre_distribution_pt, Hypre_error_messages, Hypre_method, Internal_preconditioner, Krylov_print_level, Max_iter, oomph::MPI_Helpers::mpi_has_been_initialised(), None, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Output_info, ParaSails_filter, ParaSails_nlevel, ParaSails_symmetry, ParaSails_thresh, and Tolerance.

~HypreInterface()

oomph::HypreInterface::~HypreInterface ( )

inline

Destructor.

    {
      // call function to delete solver data
      hypre_clean_up_memory();
 
      // delete teh oomph-lib distribution
      delete Hypre_distribution_pt;
    }

References hypre_clean_up_memory(), and Hypre_distribution_pt.

HypreInterface() [2/2]

oomph::HypreInterface::HypreInterface ( const HypreInterface &  )

delete

Broken copy constructor.

Member Function Documentation

disable_hypre_error_messages()

void oomph::HypreInterface::disable_hypre_error_messages ( )

inline

Turn off hypre error messages.

    {
      Hypre_error_messages = false;
    }

References Hypre_error_messages.

enable_hypre_error_messages()

void oomph::HypreInterface::enable_hypre_error_messages ( )

inline

Turn on the hypre error messages.

    {
      Hypre_error_messages = true;
    }

References Hypre_error_messages.

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

existing_preconditioner()

unsigned oomph::HypreInterface::existing_preconditioner ( )

inline

Function return value of which preconditioner (if any) is stored.

    {
      return Existing_preconditioner;
    }

References Existing_preconditioner.

existing_solver()

unsigned oomph::HypreInterface::existing_solver ( )

inline

Function to return value of which solver (if any) is currently stored.

    {
      return Existing_solver;
    }

References Existing_solver.

Referenced by oomph::HyprePreconditioner::preconditioner_solve(), and oomph::HypreSolver::resolve().

hypre_clean_up_memory()

void oomph::HypreInterface::hypre_clean_up_memory ( )

protected

Function deletes all solver data.

hypre_clean_up_memory() deletes any existing Hypre solver and Hypre matrix

  {
    // is there an existing solver
    if (Existing_solver != None)
    {
      // delete matrix
      HYPRE_IJMatrixDestroy(Matrix_ij);
 
      // delete solver
      if (Existing_solver == BoomerAMG)
      {
        HYPRE_BoomerAMGDestroy(Solver);
      }
      else if (Existing_solver == CG)
      {
        HYPRE_ParCSRPCGDestroy(Solver);
      }
      else if (Existing_solver == GMRES)
      {
        HYPRE_ParCSRGMRESDestroy(Solver);
      }
      else if (Existing_solver == BiCGStab)
      {
        HYPRE_ParCSRBiCGSTABDestroy(Solver);
      }
      else if (Existing_solver == Euclid)
      {
        HYPRE_EuclidDestroy(Solver);
      }
      else if (Existing_solver == ParaSails)
      {
        HYPRE_ParaSailsDestroy(Solver);
      }
      Existing_solver = None;
 
      // delete preconditioner
      if (Existing_preconditioner == BoomerAMG)
      {
        HYPRE_BoomerAMGDestroy(Preconditioner);
      }
      else if (Existing_preconditioner == Euclid)
      {
        HYPRE_EuclidDestroy(Preconditioner);
      }
      else if (Existing_preconditioner == ParaSails)
      {
        HYPRE_ParaSailsDestroy(Preconditioner);
      }
      Existing_preconditioner = None;
 
      // check error flag
      if (Hypre_error_messages)
      {
        std::ostringstream message;
        int err = HypreHelpers::check_HYPRE_error_flag(message);
        if (err)
        {
          OomphLibWarning(message.str(),
                          "HypreSolver::clean_up_memory()",
                          OOMPH_EXCEPTION_LOCATION);
        }
      }
    }
  }

References BoomerAMG, oomph::HypreHelpers::check_HYPRE_error_flag(), Euclid, Existing_preconditioner, Existing_solver, Hypre_error_messages, Matrix_ij, None, OOMPH_EXCEPTION_LOCATION, ParaSails, and Solver.

Referenced by oomph::HypreSolver::clean_up_memory(), oomph::HyprePreconditioner::clean_up_memory(), and ~HypreInterface().

hypre_matrix_setup()

void oomph::HypreInterface::hypre_matrix_setup ( CRDoubleMatrix *  matrix_pt )

protected

Function which sets values of First_global_row, Last_global_row and other partitioning data and creates the distributed Hypre matrix (stored in Matrix_ij/Matrix_par) from the CRDoubleMatrix.

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Helper function which creates a Hypre matrix from a CRDoubleMatrix If OOMPH-LIB has been set up for MPI use, the Hypre matrix is distributed over the available processors.

  {
    // reset Hypre's global error flag
    hypre__global_error = 0;
 
    // issue warning if the matrix is small compared to the number of processors
    if (unsigned(2 * matrix_pt->distribution_pt()->communicator_pt()->nproc()) >
        matrix_pt->nrow())
    {
      oomph_info
        << "Warning: HYPRE based solvers may fail if 2*number of processors "
        << "is greater than the number of unknowns!" << std::endl;
    }
 
    // store the distribution
    // generate the Hypre matrix
    HypreHelpers::create_HYPRE_Matrix(
      matrix_pt, Matrix_ij, Matrix_par, Hypre_distribution_pt);
 
    // Output error messages if required
    if (Hypre_error_messages)
    {
      std::ostringstream message;
      int err = HypreHelpers::check_HYPRE_error_flag(message);
      if (err)
      {
        OomphLibWarning(message.str(),
                        "HypreSolver::hypre_matrix_setup()",
                        OOMPH_EXCEPTION_LOCATION);
      }
    }
 
    // delete CRDoubleMatrix if required
    if (Delete_input_data)
    {
      matrix_pt->clear();
    }
  }

References oomph::HypreHelpers::check_HYPRE_error_flag(), oomph::CRDoubleMatrix::clear(), oomph::LinearAlgebraDistribution::communicator_pt(), oomph::HypreHelpers::create_HYPRE_Matrix(), Delete_input_data, oomph::DistributableLinearAlgebraObject::distribution_pt(), hypre__global_error, Hypre_distribution_pt, Hypre_error_messages, Matrix_ij, Matrix_par, oomph::OomphCommunicator::nproc(), oomph::CRDoubleMatrix::nrow(), OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

Referenced by oomph::HyprePreconditioner::setup(), and oomph::HypreSolver::solve().

hypre_solve()

void oomph::HypreInterface::hypre_solve ( const DoubleVector &  rhs, DoubleVector &  solution  )

protected

Helper function performs a solve if any solver exists.

Helper function performs a solve if solver data has been set up using hypre_solver_setup(...).

  {
    // Record time
    double t_start = TimingHelpers::timer();
 
    // Set up hypre vectors
    // --------------------
 
    // Hypre vector for rhs values
    HYPRE_IJVector rhs_ij;
    HYPRE_ParVector rhs_par;
 
    // Hypre vector for solution
    HYPRE_IJVector solution_ij;
    HYPRE_ParVector solution_par;
 
    // set up rhs_values and vec_indices
    HypreHelpers::create_HYPRE_Vector(
      rhs, Hypre_distribution_pt, rhs_ij, rhs_par);
 
    HypreHelpers::create_HYPRE_Vector(
      Hypre_distribution_pt, solution_ij, solution_par);
 
    // check error flag
    if (Hypre_error_messages)
    {
      std::ostringstream message;
      int err = HypreHelpers::check_HYPRE_error_flag(message);
      if (err)
      {
        OomphLibWarning(message.str(),
                        "HypreSolver::hypre_solve()",
                        OOMPH_EXCEPTION_LOCATION);
      }
    }
 
    // solve
    // -----
 
    // for solver stats
    int iterations = 0;
    double norm = 0;
 
    // Get the norm of rhs
    const double rhs_norm = rhs.norm();
    bool do_solving = false;
    if (rhs_norm > 0.0)
    {
      do_solving = true;
    }
 
#ifdef OOMPH_HAS_MPI
    // We need to check whether any processor requires to solve, if that
    // is the case then do the solving
    if (MPI_Helpers::mpi_has_been_initialised())
    {
      if (MPI_Helpers::communicator_pt()->nproc() > 1)
      {
        unsigned this_processor_do_solving = 0;
        unsigned all_processors_do_solving = 0;
        if (do_solving)
        {
          this_processor_do_solving = 1;
        }
        // Get the communicator
        OomphCommunicator* comm_pt = MPI_Helpers::communicator_pt();
        // Communicate with all procesoors
        MPI_Allreduce(&this_processor_do_solving,
                      &all_processors_do_solving,
                      1,
                      MPI_UNSIGNED,
                      MPI_SUM,
                      comm_pt->mpi_comm());
        if (all_processors_do_solving > 0)
        {
          do_solving = true;
        }
      }
    }
#endif
 
    if (do_solving)
    {
      if (Existing_solver == BoomerAMG)
      {
        HYPRE_BoomerAMGSolve(Solver, Matrix_par, rhs_par, solution_par);
        HYPRE_BoomerAMGGetNumIterations(Solver, &iterations);
        HYPRE_BoomerAMGGetFinalRelativeResidualNorm(Solver, &norm);
      }
      else if (Existing_solver == CG)
      {
        HYPRE_PCGSolve(Solver,
                       (HYPRE_Matrix)Matrix_par,
                       (HYPRE_Vector)rhs_par,
                       (HYPRE_Vector)solution_par);
        HYPRE_PCGGetNumIterations(Solver, &iterations);
        HYPRE_PCGGetFinalRelativeResidualNorm(Solver, &norm);
      }
      else if (Existing_solver == GMRES)
      {
        HYPRE_GMRESSolve(Solver,
                         (HYPRE_Matrix)Matrix_par,
                         (HYPRE_Vector)rhs_par,
                         (HYPRE_Vector)solution_par);
        HYPRE_GMRESGetNumIterations(Solver, &iterations);
        HYPRE_GMRESGetFinalRelativeResidualNorm(Solver, &norm);
      }
      else if (Existing_solver == BiCGStab)
      {
        HYPRE_BiCGSTABSolve(Solver,
                            (HYPRE_Matrix)Matrix_par,
                            (HYPRE_Vector)rhs_par,
                            (HYPRE_Vector)solution_par);
        HYPRE_BiCGSTABGetNumIterations(Solver, &iterations);
        HYPRE_BiCGSTABGetFinalRelativeResidualNorm(Solver, &norm);
      }
      else if (Existing_solver == Euclid)
      {
        HYPRE_EuclidSolve(Solver, Matrix_par, rhs_par, solution_par);
      }
      else if (Existing_solver == ParaSails)
      {
        HYPRE_ParaSailsSolve(Solver, Matrix_par, rhs_par, solution_par);
      }
 
      // output any error message
      if (Hypre_error_messages)
      {
        std::ostringstream message;
        int err = HypreHelpers::check_HYPRE_error_flag(message);
        if (err)
        {
          OomphLibWarning(message.str(),
                          "HypreSolver::hypre_solve()",
                          OOMPH_EXCEPTION_LOCATION);
        }
      }
 
    } // if (do_solving)
 
    // Copy result to solution
    unsigned nrow_local = Hypre_distribution_pt->nrow_local();
    unsigned first_row = Hypre_distribution_pt->first_row();
    int* indices = new int[nrow_local];
    for (unsigned i = 0; i < nrow_local; i++)
    {
      indices[i] = first_row + i;
    }
    LinearAlgebraDistribution* soln_dist_pt;
    if (solution.built())
    {
      soln_dist_pt = new LinearAlgebraDistribution(solution.distribution_pt());
    }
    else
    {
      soln_dist_pt = new LinearAlgebraDistribution(rhs.distribution_pt());
    }
    solution.build(Hypre_distribution_pt, 0.0);
    HYPRE_IJVectorGetValues(
      solution_ij, nrow_local, indices, solution.values_pt());
    solution.redistribute(soln_dist_pt);
    delete[] indices;
    delete soln_dist_pt;
 
    // output any error message
    if (Hypre_error_messages)
    {
      std::ostringstream message;
      int err = HypreHelpers::check_HYPRE_error_flag(message);
      if (err)
      {
        OomphLibWarning(message.str(),
                        "HypreSolver::hypre_solve()",
                        OOMPH_EXCEPTION_LOCATION);
      }
    }
 
    // deallocation
    HYPRE_IJVectorDestroy(solution_ij);
    HYPRE_IJVectorDestroy(rhs_ij);
 
    // Record time
    double solve_time = 0;
    if (Output_info)
    {
      double t_end = TimingHelpers::timer();
      solve_time = t_end - t_start;
    }
 
    // output timings and info
    if (Output_info)
    {
      oomph_info << "Time for HYPRE solve [s] : " << solve_time << std::endl;
    }
 
    // for iterative solvers output iterations and final norm
    if ((Hypre_method >= CG) && (Hypre_method <= BoomerAMG))
    {
      if (iterations > 1)
      {
        if (Output_info)
          oomph_info << "Number of iterations         : " << iterations
                     << std::endl;
        if (Output_info)
          oomph_info << "Final Relative Residual Norm : " << norm << std::endl;
      }
    }
  }

References BoomerAMG, oomph::HypreHelpers::check_HYPRE_error_flag(), oomph::MPI_Helpers::communicator_pt(), oomph::HypreHelpers::create_HYPRE_Vector(), oomph::DistributableLinearAlgebraObject::distribution_pt(), Euclid, Existing_solver, oomph::LinearAlgebraDistribution::first_row(), Hypre_distribution_pt, Hypre_error_messages, Hypre_method, i, Matrix_par, oomph::MPI_Helpers::mpi_has_been_initialised(), oomph::DoubleVector::norm(), oomph::LinearAlgebraDistribution::nrow_local(), OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Output_info, ParaSails, BiharmonicTestFunctions1::solution(), Solver, and oomph::TimingHelpers::timer().

Referenced by oomph::HyprePreconditioner::preconditioner_solve(), oomph::HypreSolver::resolve(), and oomph::HypreSolver::solve().

hypre_solver_setup()

void oomph::HypreInterface::hypre_solver_setup ( )

protected

Sets up the data required for to use as an oomph-lib LinearSolver or Preconditioner. This must be called after the Hypre matrix has been generated using hypre_matrix_setup(...).

Sets up the solver data required for use in an oomph-lib LinearSolver or Preconditioner, once the Hypre matrix has been generated using hypre_matrix_setup(...).

  {
    // Store time
    double t_start = TimingHelpers::timer();
    double t_end = 0;
 
 
    // reset Hypre's global error flag
    hypre__global_error = 0;
 
    // create dummy Hypre vectors which are required for setup
    HYPRE_IJVector dummy_sol_ij;
    HYPRE_ParVector dummy_sol_par;
    HYPRE_IJVector dummy_rhs_ij;
    HYPRE_ParVector dummy_rhs_par;
    HypreHelpers::create_HYPRE_Vector(
      Hypre_distribution_pt, dummy_sol_ij, dummy_sol_par);
    HypreHelpers::create_HYPRE_Vector(
      Hypre_distribution_pt, dummy_rhs_ij, dummy_rhs_par);
 
    // Set up internal preconditioner for CG, GMRES or BiCGSTAB
    // --------------------------------------------------------
    if ((Hypre_method >= CG) && (Hypre_method <= BiCGStab))
    {
      // AMG preconditioner
      if (Internal_preconditioner == BoomerAMG)
      {
        // set up BoomerAMG
        HYPRE_BoomerAMGCreate(&Preconditioner);
        HYPRE_BoomerAMGSetPrintLevel(Preconditioner, AMG_print_level);
        HYPRE_BoomerAMGSetMaxLevels(Preconditioner, AMG_max_levels);
        HYPRE_BoomerAMGSetMaxIter(Preconditioner, 1);
        HYPRE_BoomerAMGSetTol(Preconditioner, 0.0);
        HYPRE_BoomerAMGSetCoarsenType(Preconditioner, AMG_coarsening);
        HYPRE_BoomerAMGSetStrongThreshold(Preconditioner, AMG_strength);
        HYPRE_BoomerAMGSetMaxRowSum(Preconditioner, AMG_max_row_sum);
        HYPRE_BoomerAMGSetTruncFactor(Preconditioner, AMG_truncation);
 
        if (AMG_using_simple_smoothing)
        {
          HYPRE_BoomerAMGSetRelaxType(Preconditioner, AMG_simple_smoother);
          HYPRE_BoomerAMGSetNumSweeps(Preconditioner, AMG_smoother_iterations);
 
          // This one gives a memory leak
          // double * relaxweight = new double[AMG_max_levels];
 
          // This is how they do it in a hypre demo code
          double* relaxweight = hypre_CTAlloc(double, AMG_max_levels);
 
          for (unsigned i = 0; i < AMG_max_levels; i++)
          {
            relaxweight[i] = AMG_damping;
          }
          HYPRE_BoomerAMGSetRelaxWeight(Preconditioner, relaxweight);
        }
        else
        {
          HYPRE_BoomerAMGSetSmoothType(Preconditioner, AMG_complex_smoother);
          HYPRE_BoomerAMGSetSmoothNumLevels(Preconditioner, AMG_max_levels);
          HYPRE_BoomerAMGSetSmoothNumSweeps(Preconditioner,
                                            AMG_smoother_iterations);
 
          // If we are using Euclid then set up additional Euclid only options
          if (AMG_complex_smoother == 9)
          {
            HypreHelpers::euclid_settings_helper(
              AMGEuclidSmoother_use_block_jacobi,
              AMGEuclidSmoother_use_row_scaling,
              AMGEuclidSmoother_use_ilut,
              AMGEuclidSmoother_level,
              AMGEuclidSmoother_drop_tol,
              AMGEuclidSmoother_print_level,
              Preconditioner);
          }
        }
 
        Existing_preconditioner = BoomerAMG;
      }
 
      // Euclid preconditioner
      else if (Internal_preconditioner == Euclid)
      {
#ifdef OOMPH_HAS_MPI
        HYPRE_EuclidCreate(Hypre_distribution_pt->communicator_pt()->mpi_comm(),
                           &Preconditioner);
#else
        HYPRE_EuclidCreate(MPI_COMM_WORLD, &Preconditioner);
#endif
 
        // Set parameters
        HypreHelpers::euclid_settings_helper(Euclid_using_BJ,
                                             Euclid_rowScale,
                                             Euclid_using_ILUT,
                                             Euclid_level,
                                             Euclid_droptol,
                                             Euclid_print_level,
                                             Preconditioner);
 
        Existing_preconditioner = Euclid;
      }
 
      // ParaSails preconditioner
      else if (Internal_preconditioner == ParaSails)
      {
#ifdef OOMPH_HAS_MPI
        HYPRE_ParaSailsCreate(
          Hypre_distribution_pt->communicator_pt()->mpi_comm(),
          &Preconditioner);
#else
        HYPRE_ParaSailsCreate(MPI_COMM_WORLD, &Preconditioner);
#endif
        HYPRE_ParaSailsSetSym(Preconditioner, ParaSails_symmetry);
        HYPRE_ParaSailsSetParams(
          Preconditioner, ParaSails_thresh, ParaSails_nlevel);
        HYPRE_ParaSailsSetFilter(Preconditioner, ParaSails_filter);
        Existing_preconditioner = ParaSails;
      }
 
      // check error flag
      if (Hypre_error_messages)
      {
        std::ostringstream message;
        int err = HypreHelpers::check_HYPRE_error_flag(message);
        if (err)
        {
          OomphLibWarning(message.str(),
                          "HypreSolver::hypre_setup()",
                          OOMPH_EXCEPTION_LOCATION);
        }
      }
    } // end of setting up internal preconditioner
 
 
    // set up solver
    // -------------
    t_start = TimingHelpers::timer();
 
    // AMG solver
    if (Hypre_method == BoomerAMG)
    {
      if (Output_info)
      {
        oomph_info << "Setting up BoomerAMG, ";
      }
 
      // set up BoomerAMG
      HYPRE_BoomerAMGCreate(&Solver);
      HYPRE_BoomerAMGSetPrintLevel(Solver, AMG_print_level);
      HYPRE_BoomerAMGSetMaxLevels(Solver, AMG_max_levels);
      HYPRE_BoomerAMGSetMaxIter(Solver, Max_iter);
      HYPRE_BoomerAMGSetTol(Solver, Tolerance);
      HYPRE_BoomerAMGSetCoarsenType(Solver, AMG_coarsening);
      HYPRE_BoomerAMGSetStrongThreshold(Solver, AMG_strength);
      HYPRE_BoomerAMGSetMaxRowSum(Solver, AMG_max_row_sum);
      HYPRE_BoomerAMGSetTruncFactor(Solver, AMG_truncation);
 
      if (AMG_using_simple_smoothing)
      {
        HYPRE_BoomerAMGSetRelaxType(Solver, AMG_simple_smoother);
        HYPRE_BoomerAMGSetNumSweeps(Solver, AMG_smoother_iterations);
 
        // This one gives a memory leak
        // double * relaxweight = new double[AMG_max_levels];
 
        // This is how they do it in a hypre demo code
        double* relaxweight = hypre_CTAlloc(double, AMG_max_levels);
 
        for (unsigned i = 0; i < AMG_max_levels; i++)
        {
          relaxweight[i] = AMG_damping;
        }
        HYPRE_BoomerAMGSetRelaxWeight(Solver, relaxweight);
      }
      else
      {
        HYPRE_BoomerAMGSetSmoothType(Solver, AMG_complex_smoother);
        HYPRE_BoomerAMGSetSmoothNumLevels(Solver, AMG_max_levels);
        HYPRE_BoomerAMGSetSmoothNumSweeps(Solver, AMG_smoother_iterations);
 
        /* Other settings
         * 6 &  Schwarz smoothers & HYPRE_BoomerAMGSetDomainType,
         * HYPRE_BoomerAMGSetOverlap, \\
         *  &  & HYPRE_BoomerAMGSetVariant, HYPRE_BoomerAMGSetSchwarzRlxWeight
         * \\
         * 7 &  Pilut & HYPRE_BoomerAMGSetDropTol, HYPRE_BoomerAMGSetMaxNzPerRow
         * \\
         * 8 &  ParaSails & HYPRE_BoomerAMGSetSym, HYPRE_BoomerAMGSetLevel, \\
         * &  &  HYPRE_BoomerAMGSetFilter, HYPRE_BoomerAMGSetThreshold \\
         * 9 &  Euclid & HYPRE_BoomerAMGSetEuclidFile \\
         */
 
        // If we are using Euclid then set up additional Euclid only options
        if (AMG_complex_smoother == 9)
        {
          HypreHelpers::euclid_settings_helper(
            AMGEuclidSmoother_use_block_jacobi,
            AMGEuclidSmoother_use_row_scaling,
            AMGEuclidSmoother_use_ilut,
            AMGEuclidSmoother_level,
            AMGEuclidSmoother_drop_tol,
            AMGEuclidSmoother_print_level,
            Preconditioner);
        }
 
        // Add any others here as required...
      }
 
      //     MemoryUsage::doc_memory_usage("before amg setup [solver]");
      //     MemoryUsage::insert_comment_to_continous_top("BEFORE AMG SETUP
      //     [SOLVER]");
 
      HYPRE_BoomerAMGSetup(Solver, Matrix_par, dummy_rhs_par, dummy_sol_par);
 
      //     MemoryUsage::doc_memory_usage("after amg setup [solver]");
      //     MemoryUsage::insert_comment_to_continous_top("AFTER AMG SETUP
      //     [SOLVER]");
 
      Existing_solver = BoomerAMG;
    }
 
    // Euclid solver
    else if (Hypre_method == Euclid)
    {
      if (Output_info)
      {
        oomph_info << "Setting up Euclid, ";
      }
#ifdef OOMPH_HAS_MPI
      HYPRE_EuclidCreate(Hypre_distribution_pt->communicator_pt()->mpi_comm(),
                         &Solver);
#else
      HYPRE_EuclidCreate(MPI_COMM_WORLD, &Solver);
#endif
 
      // Set parameters
      HypreHelpers::euclid_settings_helper(Euclid_using_BJ,
                                           Euclid_rowScale,
                                           Euclid_using_ILUT,
                                           Euclid_level,
                                           Euclid_droptol,
                                           Euclid_print_level,
                                           Preconditioner);
 
      HYPRE_EuclidSetup(Solver, Matrix_par, dummy_rhs_par, dummy_sol_par);
      Existing_solver = Euclid;
    }
 
    // ParaSails preconditioner
    else if (Hypre_method == ParaSails)
    {
      if (Output_info)
      {
        oomph_info << "Setting up ParaSails, ";
      }
#ifdef OOMPH_HAS_MPI
      HYPRE_ParaSailsCreate(
        Hypre_distribution_pt->communicator_pt()->mpi_comm(), &Solver);
#else
      HYPRE_ParaSailsCreate(MPI_COMM_WORLD, &Solver);
#endif
      HYPRE_ParaSailsSetSym(Solver, ParaSails_symmetry);
      HYPRE_ParaSailsSetParams(Solver, ParaSails_thresh, ParaSails_nlevel);
      HYPRE_ParaSailsSetFilter(Solver, ParaSails_filter);
 
      HYPRE_ParaSailsSetup(Solver, Matrix_par, dummy_rhs_par, dummy_sol_par);
      Existing_solver = ParaSails;
    }
 
    // CG solver
    else if (Hypre_method == CG)
    {
      if (Output_info)
      {
        oomph_info << "Setting up CG, ";
      }
 
#ifdef OOMPH_HAS_MPI
      HYPRE_ParCSRPCGCreate(
        Hypre_distribution_pt->communicator_pt()->mpi_comm(), &Solver);
#else
      HYPRE_ParCSRPCGCreate(MPI_COMM_WORLD, &Solver);
#endif
      HYPRE_PCGSetTol(Solver, Tolerance);
      HYPRE_PCGSetLogging(Solver, 0);
      HYPRE_PCGSetPrintLevel(Solver, Krylov_print_level);
      HYPRE_PCGSetMaxIter(Solver, Max_iter);
 
      // set preconditioner
      if (Internal_preconditioner == BoomerAMG) // AMG
      {
        if (Output_info)
        {
          oomph_info << " with BoomerAMG preconditioner, ";
        }
 
        HYPRE_PCGSetPrecond(Solver,
                            (HYPRE_PtrToSolverFcn)HYPRE_BoomerAMGSolve,
                            (HYPRE_PtrToSolverFcn)HYPRE_BoomerAMGSetup,
                            Preconditioner);
      }
      else if (Internal_preconditioner == Euclid) // Euclid
      {
        if (Output_info)
        {
          oomph_info << " with Euclid ILU preconditioner, ";
        }
 
        HYPRE_PCGSetPrecond(Solver,
                            (HYPRE_PtrToSolverFcn)HYPRE_EuclidSolve,
                            (HYPRE_PtrToSolverFcn)HYPRE_EuclidSetup,
                            Preconditioner);
      }
      else if (Internal_preconditioner == ParaSails) // ParaSails
      {
        if (Output_info)
        {
          oomph_info << " with ParaSails approximate inverse preconditioner, ";
        }
 
        HYPRE_PCGSetPrecond(Solver,
                            (HYPRE_PtrToSolverFcn)HYPRE_ParaSailsSolve,
                            (HYPRE_PtrToSolverFcn)HYPRE_ParaSailsSetup,
                            Preconditioner);
      }
      else
      {
        if (Output_info)
        {
          oomph_info << " with no preconditioner";
        }
      }
 
 
      HYPRE_PCGSetup(Solver,
                     (HYPRE_Matrix)Matrix_par,
                     (HYPRE_Vector)dummy_rhs_par,
                     (HYPRE_Vector)dummy_sol_par);
 
 
      Existing_solver = CG;
    }
 
    // GMRES solver
    else if (Hypre_method == GMRES)
    {
      if (Output_info)
      {
        oomph_info << "Setting up GMRES";
      }
 
#ifdef OOMPH_HAS_MPI
      HYPRE_ParCSRGMRESCreate(
        Hypre_distribution_pt->communicator_pt()->mpi_comm(), &Solver);
#else
      HYPRE_ParCSRGMRESCreate(MPI_COMM_WORLD, &Solver);
#endif
      HYPRE_GMRESSetTol(Solver, Tolerance);
      HYPRE_GMRESSetKDim(Solver, Max_iter);
      HYPRE_GMRESSetLogging(Solver, 0);
      HYPRE_GMRESSetPrintLevel(Solver, Krylov_print_level);
      HYPRE_GMRESSetMaxIter(Solver, Max_iter);
 
      // set preconditioner
      if (Internal_preconditioner == BoomerAMG) // AMG
      {
        if (Output_info)
        {
          oomph_info << " with BoomerAMG preconditioner, ";
        }
 
        HYPRE_GMRESSetPrecond(Solver,
                              (HYPRE_PtrToSolverFcn)HYPRE_BoomerAMGSolve,
                              (HYPRE_PtrToSolverFcn)HYPRE_BoomerAMGSetup,
                              Preconditioner);
      }
      else if (Internal_preconditioner == Euclid) // Euclid
      {
        if (Output_info)
        {
          oomph_info << " with Euclid ILU preconditioner, ";
        }
 
        HYPRE_GMRESSetPrecond(Solver,
                              (HYPRE_PtrToSolverFcn)HYPRE_EuclidSolve,
                              (HYPRE_PtrToSolverFcn)HYPRE_EuclidSetup,
                              Preconditioner);
      }
      else if (Internal_preconditioner == ParaSails) // ParaSails
      {
        if (Output_info)
        {
          oomph_info << " with ParaSails approximate inverse preconditioner, ";
        }
 
        HYPRE_GMRESSetPrecond(Solver,
                              (HYPRE_PtrToSolverFcn)HYPRE_ParaSailsSolve,
                              (HYPRE_PtrToSolverFcn)HYPRE_ParaSailsSetup,
                              Preconditioner);
      }
      else
      {
        if (Output_info)
        {
          oomph_info << " with no preconditioner";
        }
      }
 
      HYPRE_GMRESSetup(Solver,
                       (HYPRE_Matrix)Matrix_par,
                       (HYPRE_Vector)dummy_rhs_par,
                       (HYPRE_Vector)dummy_sol_par);
 
      Existing_solver = GMRES;
    }
 
    // BiCGStab solver
    else if (Hypre_method == BiCGStab)
    {
      if (Output_info)
      {
        oomph_info << "Setting up BiCGStab";
      }
#ifdef OOMPH_HAS_MPI
      HYPRE_ParCSRBiCGSTABCreate(
        Hypre_distribution_pt->communicator_pt()->mpi_comm(), &Solver);
#else
      HYPRE_ParCSRBiCGSTABCreate(MPI_COMM_WORLD, &Solver);
#endif
      HYPRE_BiCGSTABSetTol(Solver, Tolerance);
      HYPRE_BiCGSTABSetLogging(Solver, 0);
      HYPRE_BiCGSTABSetPrintLevel(Solver, Krylov_print_level);
      HYPRE_BiCGSTABSetMaxIter(Solver, Max_iter);
 
      // set preconditioner
      if (Internal_preconditioner == BoomerAMG) // AMG
      {
        if (Output_info)
        {
          oomph_info << " with BoomerAMG preconditioner, ";
        }
 
        HYPRE_BiCGSTABSetPrecond(Solver,
                                 (HYPRE_PtrToSolverFcn)HYPRE_BoomerAMGSolve,
                                 (HYPRE_PtrToSolverFcn)HYPRE_BoomerAMGSetup,
                                 Preconditioner);
      }
      else if (Internal_preconditioner == Euclid) // Euclid
      {
        if (Output_info)
        {
          oomph_info << " with Euclid ILU preconditioner, ";
        }
 
        HYPRE_BiCGSTABSetPrecond(Solver,
                                 (HYPRE_PtrToSolverFcn)HYPRE_EuclidSolve,
                                 (HYPRE_PtrToSolverFcn)HYPRE_EuclidSetup,
                                 Preconditioner);
      }
      else if (Internal_preconditioner == ParaSails) // ParaSails
      {
        if (Output_info)
        {
          oomph_info << " with ParaSails approximate inverse preconditioner, ";
        }
 
        HYPRE_BiCGSTABSetPrecond(Solver,
                                 (HYPRE_PtrToSolverFcn)HYPRE_ParaSailsSolve,
                                 (HYPRE_PtrToSolverFcn)HYPRE_ParaSailsSetup,
                                 Preconditioner);
      }
      else
      {
        if (Output_info)
        {
          oomph_info << " with no preconditioner, ";
        }
      }
 
      HYPRE_BiCGSTABSetup(Solver,
                          (HYPRE_Matrix)Matrix_par,
                          (HYPRE_Vector)dummy_rhs_par,
                          (HYPRE_Vector)dummy_sol_par);
 
      Existing_solver = BiCGStab;
    }
 
    // no solver exists for this value of Solver flag
    else
    {
      std::ostringstream error_message;
      error_message << "Solver has been set to an invalid value. "
                    << "current value=" << Solver;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    t_end = TimingHelpers::timer();
    double solver_setup_time = t_end - t_start;
 
    // destroy dummy hypre vectors
    HYPRE_IJVectorDestroy(dummy_sol_ij);
    HYPRE_IJVectorDestroy(dummy_rhs_ij);
 
    // check error flag
    if (Hypre_error_messages)
    {
      std::ostringstream message;
      int err = HypreHelpers::check_HYPRE_error_flag(message);
      if (err)
      {
        OomphLibWarning(message.str(),
                        "HypreSolver::hypre_solver_setup()",
                        OOMPH_EXCEPTION_LOCATION);
      }
    }
 
    // output times
    if (Output_info)
    {
      oomph_info << "time for setup [s] : " << solver_setup_time << std::endl;
    }
  }

References AMG_coarsening, AMG_complex_smoother, AMG_damping, AMG_max_levels, AMG_max_row_sum, AMG_print_level, AMG_simple_smoother, AMG_smoother_iterations, AMG_strength, AMG_truncation, AMG_using_simple_smoothing, AMGEuclidSmoother_drop_tol, AMGEuclidSmoother_level, AMGEuclidSmoother_print_level, AMGEuclidSmoother_use_block_jacobi, AMGEuclidSmoother_use_ilut, AMGEuclidSmoother_use_row_scaling, BiCGStab, BoomerAMG, CG, oomph::HypreHelpers::check_HYPRE_error_flag(), oomph::LinearAlgebraDistribution::communicator_pt(), oomph::HypreHelpers::create_HYPRE_Vector(), Euclid, Euclid_droptol, Euclid_level, Euclid_print_level, Euclid_rowScale, oomph::HypreHelpers::euclid_settings_helper(), Euclid_using_BJ, Euclid_using_ILUT, Existing_preconditioner, Existing_solver, GMRES, hypre__global_error, Hypre_distribution_pt, Hypre_error_messages, Hypre_method, i, Internal_preconditioner, Krylov_print_level, Matrix_par, Max_iter, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Output_info, ParaSails, ParaSails_filter, ParaSails_nlevel, ParaSails_symmetry, ParaSails_thresh, Solver, oomph::TimingHelpers::timer(), and Tolerance.

Referenced by oomph::HyprePreconditioner::setup(), and oomph::HypreSolver::solve().

operator=()

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

delete

Broken assignment operator.

Member Data Documentation

AMG_coarsening

unsigned oomph::HypreInterface::AMG_coarsening

protected

AMG coarsening strategy. Coarsening types include: 0 = CLJP (parallel coarsening using independent sets) 1 = classical RS with no boundary treatment (not recommended in parallel) 3 = modified RS with 3rd pass to add C points on the boundaries 6 = Falgout (uses 1 then CLJP using interior coarse points as first independent set) 8 = PMIS (parallel coarsening using independent sets - lower complexities than 0, maybe also slower convergence) 10= HMIS (one pass RS on each processor then PMIS on interior coarse points as first independent set) 11= One pass RS on each processor (not recommended)

Referenced by oomph::HypreSolver::amg_coarsening(), oomph::HyprePreconditioner::amg_coarsening(), hypre_solver_setup(), and HypreInterface().

AMG_complex_smoother

unsigned oomph::HypreInterface::AMG_complex_smoother

protected

Complex smoothing methods used in BoomerAMG. Relaxation types are: 6 = Schwarz 7 = Pilut 8 = ParaSails 9 = Euclid To use these methods set AMG_using_simple_smoothing to false

Referenced by oomph::HypreSolver::amg_complex_smoother(), oomph::HyprePreconditioner::amg_complex_smoother(), hypre_solver_setup(), and HypreInterface().

AMG_damping

double oomph::HypreInterface::AMG_damping

protected

Damping factor for BoomerAMG smoothed Jacobi or hybrid SOR.

Referenced by oomph::HypreSolver::amg_damping(), oomph::HyprePreconditioner::amg_damping(), hypre_solver_setup(), and HypreInterface().

AMG_max_levels

unsigned oomph::HypreInterface::AMG_max_levels

protected

Maximum number of levels used in AMG.

Referenced by oomph::HypreSolver::amg_max_levels(), oomph::HyprePreconditioner::amg_max_levels(), hypre_solver_setup(), and HypreInterface().

AMG_max_row_sum

double oomph::HypreInterface::AMG_max_row_sum

protected

Parameter to identify diagonally dominant parts of the matrix in AMG.

Referenced by oomph::HypreSolver::amg_max_row_sum(), oomph::HyprePreconditioner::amg_max_row_sum(), hypre_solver_setup(), and HypreInterface().

AMG_print_level

unsigned oomph::HypreInterface::AMG_print_level

protected

Used to set the Hypre printing level for AMG 0: no printout 1: print setup information 2: print solve information 3: print setup and solve information

Referenced by oomph::HypreSolver::amg_print_level(), oomph::HyprePreconditioner::amg_print_level(), hypre_solver_setup(), and HypreInterface().

AMG_simple_smoother

unsigned oomph::HypreInterface::AMG_simple_smoother

protected

Simple smoothing methods used in BoomerAMG. Relaxation types include: 0 = Jacobi 1 = Gauss-Seidel, sequential (very slow in parallel!) 2 = Gauss-Seidel, interior points in parallel, boundary sequential (slow in parallel!) 3 = hybrid Gauss-Seidel or SOR, forward solve 4 = hybrid Gauss-Seidel or SOR, backward solve 6 = hybrid symmetric Gauss-Seidel or SSOR To use these methods set AMG_using_simple_smoothing to true

Referenced by oomph::HypreSolver::amg_simple_smoother(), oomph::HyprePreconditioner::amg_simple_smoother(), hypre_solver_setup(), and HypreInterface().

AMG_smoother_iterations

unsigned oomph::HypreInterface::AMG_smoother_iterations

protected

The number of smoother iterations to apply.

Referenced by oomph::HypreSolver::amg_smoother_iterations(), oomph::HyprePreconditioner::amg_smoother_iterations(), hypre_solver_setup(), and HypreInterface().

AMG_strength

double oomph::HypreInterface::AMG_strength

protected

Connection strength threshold parameter for BoomerAMG.

Referenced by oomph::HypreSolver::amg_strength(), oomph::HyprePreconditioner::amg_strength(), hypre_solver_setup(), and HypreInterface().

AMG_truncation

double oomph::HypreInterface::AMG_truncation

protected

Interpolation truncation factor for BoomerAMG.

Referenced by oomph::HypreSolver::amg_truncation(), oomph::HyprePreconditioner::amg_truncation(), hypre_solver_setup(), and HypreInterface().

AMG_using_simple_smoothing

bool oomph::HypreInterface::AMG_using_simple_smoothing

protected

Flag to determine whether simple smoothers (determined by the AMG_simple_smoother flag) or complex smoothers (determined by the AMG_complex_smoother flag are used in AMG

Referenced by oomph::HypreSolver::amg_using_complex_smoothing(), oomph::HyprePreconditioner::amg_using_complex_smoothing(), oomph::HypreSolver::amg_using_simple_smoothing(), oomph::HyprePreconditioner::amg_using_simple_smoothing(), oomph::HyprePreconditioner::amg_using_simple_smoothing_flag(), hypre_solver_setup(), and HypreInterface().

AMGEuclidSmoother_drop_tol

double oomph::HypreInterface::AMGEuclidSmoother_drop_tol

Referenced by hypre_solver_setup(), and HypreInterface().

AMGEuclidSmoother_level

unsigned oomph::HypreInterface::AMGEuclidSmoother_level

Referenced by hypre_solver_setup(), and HypreInterface().

AMGEuclidSmoother_print_level

unsigned oomph::HypreInterface::AMGEuclidSmoother_print_level

Referenced by hypre_solver_setup(), and HypreInterface().

AMGEuclidSmoother_use_block_jacobi

bool oomph::HypreInterface::AMGEuclidSmoother_use_block_jacobi

Referenced by hypre_solver_setup(), and HypreInterface().

AMGEuclidSmoother_use_ilut

bool oomph::HypreInterface::AMGEuclidSmoother_use_ilut

Referenced by hypre_solver_setup(), and HypreInterface().

AMGEuclidSmoother_use_row_scaling

bool oomph::HypreInterface::AMGEuclidSmoother_use_row_scaling

Referenced by hypre_solver_setup(), and HypreInterface().

Delete_input_data

bool oomph::HypreInterface::Delete_input_data

protected

Internal flag which is true when hypre_setup or hypre_solve can delete input matrix.

Referenced by hypre_matrix_setup(), oomph::HyprePreconditioner::setup(), and oomph::HypreSolver::solve().

Delete_matrix

bool oomph::HypreInterface::Delete_matrix

private

Hypre copies matrix data from oomph-lib's CRDoubleMatrix into its own data structures, doubling the memory requirements. 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.

Euclid_droptol

double oomph::HypreInterface::Euclid_droptol

protected

Euclid drop tolerance for ILU(k) and ILUT factorization.

Referenced by oomph::HypreSolver::euclid_droptol(), oomph::HyprePreconditioner::euclid_droptol(), hypre_solver_setup(), and HypreInterface().

Euclid_level

int oomph::HypreInterface::Euclid_level

protected

Euclid level parameter for ILU(k) factorization.

Referenced by oomph::HypreSolver::euclid_level(), oomph::HyprePreconditioner::euclid_level(), hypre_solver_setup(), and HypreInterface().

Euclid_print_level

unsigned oomph::HypreInterface::Euclid_print_level

protected

Flag 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

Referenced by oomph::HypreSolver::euclid_print_level(), oomph::HyprePreconditioner::euclid_print_level(), hypre_solver_setup(), and HypreInterface().

Euclid_rowScale

bool oomph::HypreInterface::Euclid_rowScale

protected

Flag to switch on Euclid row scaling.

Referenced by oomph::HypreSolver::disable_euclid_rowScale(), oomph::HyprePreconditioner::disable_euclid_rowScale(), oomph::HypreSolver::enable_euclid_rowScale(), oomph::HyprePreconditioner::enable_euclid_rowScale(), hypre_solver_setup(), and HypreInterface().

Euclid_using_BJ

bool oomph::HypreInterface::Euclid_using_BJ

protected

Flag to determine if Block Jacobi is used instead of PILU.

Referenced by oomph::HypreSolver::disable_euclid_using_BJ(), oomph::HyprePreconditioner::disable_euclid_using_BJ(), oomph::HypreSolver::enable_euclid_using_BJ(), oomph::HyprePreconditioner::enable_euclid_using_BJ(), hypre_solver_setup(), and HypreInterface().

Euclid_using_ILUT

bool oomph::HypreInterface::Euclid_using_ILUT

protected

Flag to determine if ILUT (if true) or ILU(k) is used in Euclid.

Referenced by oomph::HypreSolver::euclid_using_ILUK(), oomph::HyprePreconditioner::euclid_using_ILUK(), oomph::HypreSolver::euclid_using_ILUT(), oomph::HyprePreconditioner::euclid_using_ILUT(), hypre_solver_setup(), and HypreInterface().

Existing_preconditioner

unsigned oomph::HypreInterface::Existing_preconditioner

private

Used to keep track of which preconditioner (if any) is currently stored.

Referenced by existing_preconditioner(), hypre_clean_up_memory(), hypre_solver_setup(), and HypreInterface().

Existing_solver

unsigned oomph::HypreInterface::Existing_solver

private

Used to keep track of which solver (if any) is currently stored.

Referenced by existing_solver(), hypre_clean_up_memory(), hypre_solve(), hypre_solver_setup(), and HypreInterface().

Hypre_distribution_pt

LinearAlgebraDistribution* oomph::HypreInterface::Hypre_distribution_pt

private

the distribution for this helpers-

Referenced by hypre_matrix_setup(), hypre_solve(), hypre_solver_setup(), HypreInterface(), and ~HypreInterface().

Hypre_error_messages

bool oomph::HypreInterface::Hypre_error_messages

protected

Flag to determine if non-zero values of the Hypre error flag plus Hypre error messages are output to screen at various points in the solve function, i.e. after:

1. setting up the Hypre matrix
2. setting up the preconditioner
3. setting up the solver
4. setting up the Hypre vectors
5. solving
6. getting the solution vector
7. deallocation of solver data

Referenced by disable_hypre_error_messages(), enable_hypre_error_messages(), hypre_clean_up_memory(), hypre_matrix_setup(), hypre_solve(), hypre_solver_setup(), and HypreInterface().

Hypre_method

unsigned oomph::HypreInterface::Hypre_method

protected

Hypre method flag. Valid values are specified in enumeration.

Referenced by oomph::HypreSolver::hypre_method(), oomph::HyprePreconditioner::hypre_method(), hypre_solve(), hypre_solver_setup(), HypreInterface(), oomph::HyprePreconditioner::HyprePreconditioner(), oomph::HyprePreconditioner::use_BoomerAMG(), oomph::HyprePreconditioner::use_Euclid(), and oomph::HyprePreconditioner::use_ParaSails().

Internal_preconditioner

unsigned oomph::HypreInterface::Internal_preconditioner

protected

Preconditioner method flag used with Hypre's PCG, GMRES and BiCGStab in solve(...) or resolve(...). Valid values are BoomerAMG, Euclid, ParaSails or None (all enumerated above), for any other value no preconditioner is set.

Referenced by hypre_solver_setup(), HypreInterface(), oomph::HyprePreconditioner::HyprePreconditioner(), oomph::HypreSolver::internal_preconditioner(), and oomph::HyprePreconditioner::internal_preconditioner().

Krylov_print_level

unsigned oomph::HypreInterface::Krylov_print_level

protected

Used to set the Hypre printing level for the Krylov subspace solvers

Referenced by hypre_solver_setup(), HypreInterface(), and oomph::HypreSolver::krylov_print_level().

Matrix_ij

HYPRE_IJMatrix oomph::HypreInterface::Matrix_ij

private

The Hypre_IJMatrix version of the matrix used in solve(...), resolve(...) or preconditioner_solve(...).

Referenced by hypre_clean_up_memory(), and hypre_matrix_setup().

Matrix_par

HYPRE_ParCSRMatrix oomph::HypreInterface::Matrix_par

private

The Hypre_ParCSRMatrix version of the matrix used in solve(...), resolve(...) or preconditioner_solve(...).

Referenced by hypre_matrix_setup(), hypre_solve(), and hypre_solver_setup().

Max_iter

unsigned oomph::HypreInterface::Max_iter

protected

Maximum number of iterations used in solver.

Referenced by oomph::HyprePreconditioner::amg_iterations(), hypre_solver_setup(), HypreInterface(), oomph::HyprePreconditioner::HyprePreconditioner(), oomph::HypreSolver::max_iter(), and oomph::HyprePreconditioner::set_amg_iterations().

Output_info

bool oomph::HypreInterface::Output_info

protected

Flag is true to output info and results of timings.

Referenced by hypre_solve(), hypre_solver_setup(), HypreInterface(), oomph::HyprePreconditioner::preconditioner_solve(), oomph::HypreSolver::resolve(), oomph::HyprePreconditioner::setup(), and oomph::HypreSolver::solve().

ParaSails_filter

double oomph::HypreInterface::ParaSails_filter

protected

ParaSails filter parameter.

Referenced by hypre_solver_setup(), HypreInterface(), oomph::HypreSolver::parasails_filter(), and oomph::HyprePreconditioner::parasails_filter().

ParaSails_nlevel

int oomph::HypreInterface::ParaSails_nlevel

protected

ParaSails nlevel parameter.

Referenced by hypre_solver_setup(), HypreInterface(), oomph::HypreSolver::parasails_nlevel(), and oomph::HyprePreconditioner::parasails_nlevel().

ParaSails_symmetry

int oomph::HypreInterface::ParaSails_symmetry

protected

ParaSails symmetry flag, used to inform ParaSails of Symmetry of definitenss of problem and type of ParaSails preconditioner: 0 = nonsymmetric and/or indefinite problem, nonsymmetric preconditioner 1 = SPD problem, and SPD (factored preconditioner) 2 = nonsymmetric, definite problem and SDP (factored preconditoner)

Referenced by hypre_solver_setup(), HypreInterface(), oomph::HypreSolver::parasails_symmetry(), and oomph::HyprePreconditioner::parasails_symmetry().

ParaSails_thresh

double oomph::HypreInterface::ParaSails_thresh

protected

ParaSails thresh parameter.

Referenced by hypre_solver_setup(), HypreInterface(), oomph::HypreSolver::parasails_thresh(), and oomph::HyprePreconditioner::parasails_thresh().

Preconditioner

HYPRE_Solver oomph::HypreInterface::Preconditioner

private

The internal Hypre preconditioner used in conjunction with Solver. [This is a C structure!]

Solver

HYPRE_Solver oomph::HypreInterface::Solver

private

The Hypre solver used in solve(...), resolve(...) or preconditioner_solve(...). [This is a C structure!]

Referenced by hypre_clean_up_memory(), hypre_solve(), and hypre_solver_setup().

Tolerance

double oomph::HypreInterface::Tolerance

protected

Tolerance used to terminate solver.

Referenced by hypre_solver_setup(), HypreInterface(), oomph::HyprePreconditioner::HyprePreconditioner(), and oomph::HypreSolver::tolerance().

---

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

• hypre_solver.h
• hypre_solver.cc