libMesh::LaspackLinearSolver< T > Class Template Reference

#include <laspack_linear_solver.h>

Inheritance diagram for libMesh::LaspackLinearSolver< T >:

[legend]

List of all members.

Public Member Functions
	LaspackLinearSolver ()
	~LaspackLinearSolver ()
void	clear ()
void	init ()
std::pair< unsigned int, Real >	solve (SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its)
std::pair< unsigned int, Real >	adjoint_solve (SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its)
std::pair< unsigned int, Real >	solve (SparseMatrix< T > &matrix, SparseMatrix< T > &pc, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its)
std::pair< unsigned int, Real >	solve (const ShellMatrix< T > &shell_matrix, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const double tol, const unsigned int m_its)
virtual std::pair< unsigned int, Real >	solve (const ShellMatrix< T > &shell_matrix, const SparseMatrix< T > &precond_matrix, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const double tol, const unsigned int m_its)
virtual void	print_converged_reason ()
bool	initialized () const
SolverType	solver_type () const
void	set_solver_type (const SolverType st)
PreconditionerType	preconditioner_type () const
void	set_preconditioner_type (const PreconditionerType pct)
void	attach_preconditioner (Preconditioner< T > *preconditioner)
virtual void	reuse_preconditioner (bool)
bool	get_same_preconditioner ()
virtual void	restrict_solve_to (const std::vector< unsigned int > *const dofs, const SubsetSolveMode subset_solve_mode=SUBSET_ZERO)
std::pair< unsigned int, Real >	solve (SparseMatrix< T > &matrix, SparseMatrix< T > *precond_matrix, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int)
std::pair< unsigned int, Real >	solve (const ShellMatrix< T > &matrix, const SparseMatrix< T > *precond_matrix, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int)
Static Public Member Functions
static AutoPtr< LinearSolver< T > >	build (const SolverPackage solver_package=libMesh::default_solver_package())
static std::string	get_info ()
static void	print_info (std::ostream &out=libMesh::out)
static unsigned int	n_objects ()
static void	enable_print_counter_info ()
static void	disable_print_counter_info ()
Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
Protected Member Functions
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Protected Attributes
SolverType	_solver_type
PreconditionerType	_preconditioner_type
bool	_is_initialized
Preconditioner< T > *	_preconditioner
bool	same_preconditioner
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex
static bool	_enable_print_counter = true
Private Member Functions
void	set_laspack_preconditioner_type ()
Private Attributes
PrecondProcType	_precond_type

---

Detailed Description

template<typename T>
class libMesh::LaspackLinearSolver< T >

This class provides an interface to Laspack iterative solvers that is compatible with the libMesh LinearSolver<>

Author:

Benjamin Kirk, 2002-2007

Definition at line 53 of file laspack_linear_solver.h.

---

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 113 of file reference_counter.h.

---

Constructor & Destructor Documentation

template<typename T >

libMesh::LaspackLinearSolver< T >::LaspackLinearSolver

(

)

[inline]

Constructor. Initializes Laspack data structures

Definition at line 154 of file laspack_linear_solver.h.

                                             :
  _precond_type (ILUPrecond)
{
}

template<typename T >

libMesh::LaspackLinearSolver< T >::~LaspackLinearSolver

(

)

[inline]

Destructor.

Definition at line 163 of file laspack_linear_solver.h.

References libMesh::LaspackLinearSolver< T >::clear().

{
  this->clear ();
}

---

Member Function Documentation

template<typename T >

std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::adjoint_solve	(	SparseMatrix< T > &	matrix,
		NumericVector< T > &	solution,
		NumericVector< T > &	rhs,
		const double	tol,
		const unsigned int	m_its
	)			[inline, virtual]

Call the Laspack solver to solve A^T x = b

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 284 of file laspack_linear_solver.C.

References libMesh::LaspackLinearSolver< T >::_precond_type, libMesh::LaspackMatrix< T >::_QMat, libMesh::LinearSolver< T >::_solver_type, libMeshEnums::BICG, libMeshEnums::BICGSTAB, libMeshEnums::CG, libMeshEnums::CGN, libMeshEnums::CGS, libMesh::LaspackMatrix< T >::close(), libMesh::err, libMeshEnums::GMRES, libMesh::LaspackLinearSolver< T >::init(), libMeshEnums::JACOBI, libMeshEnums::QMR, libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type(), libMesh::LaspackLinearSolver< T >::solve(), and libMeshEnums::SSOR.

{
  START_LOG("adjoint_solve()", "LaspackLinearSolver");
  this->init ();

  // Make sure the data passed in are really in Laspack types
  LaspackMatrix<T>* matrix   = libmesh_cast_ptr<LaspackMatrix<T>*>(&matrix_in);
  LaspackVector<T>* solution = libmesh_cast_ptr<LaspackVector<T>*>(&solution_in);
  LaspackVector<T>* rhs      = libmesh_cast_ptr<LaspackVector<T>*>(&rhs_in);

  // Zero-out the solution to prevent the solver from exiting in 0
  // iterations (?)
  //TODO:[BSK] Why does Laspack do this?  Comment out this and try ex13...
  solution->zero();

  // Close the matrix and vectors in case this wasn't already done.
  matrix->close ();
  solution->close ();
  rhs->close ();

  // Set the preconditioner type
  this->set_laspack_preconditioner_type ();

  // Set the solver tolerance
  SetRTCAccuracy (tol);

  // Solve the linear system
  switch (this->_solver_type)
    {
      // Conjugate-Gradient
    case CG:
      {
        CGIter (Transp_Q(&matrix->_QMat),
                &solution->_vec,
                &rhs->_vec,
                m_its,
                _precond_type,
                1.);
        break;
      }

      // Conjugate-Gradient Normalized
    case CGN:
      {
        CGNIter (Transp_Q(&matrix->_QMat),
                 &solution->_vec,
                 &rhs->_vec,
                 m_its,
                 _precond_type,
                 1.);
        break;
      }

      // Conjugate-Gradient Squared
    case CGS:
      {
        CGSIter (Transp_Q(&matrix->_QMat),
                 &solution->_vec,
                 &rhs->_vec,
                 m_its,
                 _precond_type,
                 1.);
        break;
      }

      // Bi-Conjugate Gradient
    case BICG:
      {
        BiCGIter (Transp_Q(&matrix->_QMat),
                  &solution->_vec,
                  &rhs->_vec,
                  m_its,
                  _precond_type,
                  1.);
        break;
      }

      // Bi-Conjugate Gradient Stabilized
    case BICGSTAB:
      {
        BiCGSTABIter (Transp_Q(&matrix->_QMat),
                      &solution->_vec,
                      &rhs->_vec,
                      m_its,
                      _precond_type,
                      1.);
        break;
      }

      // Quasi-Minimum Residual
    case QMR:
      {
        QMRIter (Transp_Q(&matrix->_QMat),
                 &solution->_vec,
                 &rhs->_vec,
                 m_its,
                 _precond_type,
                 1.);
        break;
      }

      // Symmetric over-relaxation
    case SSOR:
      {
        SSORIter (Transp_Q(&matrix->_QMat),
                  &solution->_vec,
                  &rhs->_vec,
                  m_its,
                  _precond_type,
                  1.);
        break;
      }

      // Jacobi Relaxation
    case JACOBI:
      {
        JacobiIter (Transp_Q(&matrix->_QMat),
                    &solution->_vec,
                    &rhs->_vec,
                    m_its,
                    _precond_type,
                    1.);
        break;
      }

      // Generalized Minimum Residual
    case GMRES:
      {
        SetGMRESRestart (30);
        GMRESIter (Transp_Q(&matrix->_QMat),
                   &solution->_vec,
                   &rhs->_vec,
                   m_its,
                   _precond_type,
                   1.);
        break;
      }

      // Unknown solver, use GMRES
    default:
      {
        libMesh::err << "ERROR:  Unsupported LASPACK Solver: "
                      << this->_solver_type      << std::endl
                      << "Continuing with GMRES" << std::endl;

        this->_solver_type = GMRES;

        return this->solve (*matrix,
                            *solution,
                            *rhs,
                            tol,
                            m_its);
      }
    }

  // Check for an error
  if (LASResult() != LASOK)
    {
      libMesh::err << "ERROR:  LASPACK Error: " << std::endl;
      WriteLASErrDescr(stdout);
      libmesh_error();
    }

  STOP_LOG("adjoint_solve()", "LaspackLinearSolver");
  // Get the convergence step # and residual
  return std::make_pair(GetLastNoIter(), GetLastAccuracy());
}

template<typename T>

void libMesh::LinearSolver< T >::attach_preconditioner

(

Preconditioner< T > *

preconditioner

)

[inline, inherited]

Attaches a Preconditioner object to be used

Definition at line 105 of file linear_solver.C.

References libMesh::LinearSolver< T >::_is_initialized, libMesh::LinearSolver< T >::_preconditioner, libMesh::LinearSolver< T >::_preconditioner_type, libMesh::err, and libMeshEnums::SHELL_PRECOND.

{
  if(this->_is_initialized)
  {
    libMesh::err<<"Preconditioner must be attached before the solver is initialized!"<<std::endl;
    libmesh_error();
  }

  _preconditioner_type = SHELL_PRECOND;
  _preconditioner = preconditioner;
}

template<typename T >

AutoPtr< LinearSolver< T > > libMesh::LinearSolver< T >::build

(

const SolverPackage

solver_package = libMesh::default_solver_package()

)

[inline, static, inherited]

Builds a LinearSolver using the linear solver package specified by solver_package

Definition at line 39 of file linear_solver.C.

References libMesh::err, libMesh::LASPACK_SOLVERS, libMeshEnums::PETSC_SOLVERS, and libMesh::TRILINOS_SOLVERS.

{
  // Build the appropriate solver
  switch (solver_package)
    {


#ifdef LIBMESH_HAVE_LASPACK
    case LASPACK_SOLVERS:
      {
        AutoPtr<LinearSolver<T> > ap(new LaspackLinearSolver<T>);
        return ap;
      }
#endif


#ifdef LIBMESH_HAVE_PETSC
    case PETSC_SOLVERS:
      {
        AutoPtr<LinearSolver<T> > ap(new PetscLinearSolver<T>);
        return ap;
      }
#endif


#ifdef LIBMESH_HAVE_TRILINOS
    case TRILINOS_SOLVERS:
      {
        AutoPtr<LinearSolver<T> > ap(new AztecLinearSolver<T>);
        return ap;
      }
#endif

    default:
      libMesh::err << "ERROR:  Unrecognized solver package: "
                    << solver_package
                    << std::endl;
      libmesh_error();
    }

  AutoPtr<LinearSolver<T> > ap(NULL);
  return ap;
}

template<typename T >

void libMesh::LaspackLinearSolver< T >::clear

(

)

[inline, virtual]

Release all memory and clear data structures.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 79 of file laspack_linear_solver.C.

References libMesh::LinearSolver< T >::_is_initialized, libMesh::LinearSolver< T >::_preconditioner_type, libMesh::LinearSolver< T >::_solver_type, libMeshEnums::GMRES, libMeshEnums::ILU_PRECOND, and libMesh::LinearSolver< T >::initialized().

Referenced by libMesh::LaspackLinearSolver< T >::~LaspackLinearSolver().

{
  if (this->initialized())
    {
      this->_is_initialized = false;

      this->_solver_type         = GMRES;
      this->_preconditioner_type = ILU_PRECOND;
    }
}

void libMesh::ReferenceCounter::disable_print_counter_info

(

)

[static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = false;
  return;
}

void libMesh::ReferenceCounter::enable_print_counter_info

(

)

[static, inherited]

Methods to enable/disable the reference counter output from print_info()

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

std::string libMesh::ReferenceCounter::get_info

(

)

[static, inherited]

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

template<typename T >

bool libMesh::LinearSolver< T >::get_same_preconditioner

(

)

[inline, inherited]

Definition at line 285 of file linear_solver.h.

References libMesh::LinearSolver< T >::same_preconditioner.

{
  return same_preconditioner;
}

void libMesh::ReferenceCounter::increment_constructor_count

(

const std::string &

name

)

[inline, protected, inherited]

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 163 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.first++;
}

void libMesh::ReferenceCounter::increment_destructor_count

(

const std::string &

name

)

[inline, protected, inherited]

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 176 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.second++;
}

template<typename T >

void libMesh::LaspackLinearSolver< T >::init

(

)

[inline, virtual]

Initialize data structures if not done so already.

Implements libMesh::LinearSolver< T >.

Definition at line 93 of file laspack_linear_solver.C.

References libMesh::LinearSolver< T >::_is_initialized, and libMesh::LinearSolver< T >::initialized().

Referenced by libMesh::LaspackLinearSolver< T >::adjoint_solve(), and libMesh::LaspackLinearSolver< T >::solve().

{
  // Initialize the data structures if not done so already.
  if (!this->initialized())
    {
      this->_is_initialized = true;
    }

 // SetRTCAuxProc (print_iter_accuracy);
}

template<typename T>

bool libMesh::LinearSolver< T >::initialized

(

)

const [inline, inherited]

Returns:

true if the data structures are initialized, false otherwise.

Definition at line 81 of file linear_solver.h.

Referenced by libMesh::AztecLinearSolver< T >::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::LaspackLinearSolver< T >::clear(), libMesh::AztecLinearSolver< T >::init(), libMesh::PetscLinearSolver< T >::init(), and libMesh::LaspackLinearSolver< T >::init().

{ return _is_initialized; }

static unsigned int libMesh::ReferenceCounter::n_objects

(

)

[inline, static, inherited]

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

  { return _n_objects; }

template<typename T >

PreconditionerType libMesh::LinearSolver< T >::preconditioner_type

(

)

const [inline, inherited]

Returns the type of preconditioner to use.

Definition at line 85 of file linear_solver.C.

References libMesh::LinearSolver< T >::_preconditioner, and libMesh::LinearSolver< T >::_preconditioner_type.

{
  if(_preconditioner)
    return _preconditioner->type();

  return _preconditioner_type;
}

template<typename T >

void libMesh::LaspackLinearSolver< T >::print_converged_reason

(

)

[inline, virtual]

Prints a useful message about why the latest linear solve con(di)verged.

Implements libMesh::LinearSolver< T >.

Definition at line 518 of file laspack_linear_solver.C.

References libMesh::out.

{
  libMesh::out << "print_converged_reason() is currently only supported"
                << "with Petsc 2.3.1 and later." << std::endl;
}

void libMesh::ReferenceCounter::print_info

(

std::ostream &

out = libMesh::out

)

[static, inherited]

Prints the reference information, by default to libMesh::out.

Definition at line 88 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

{
  if( _enable_print_counter ) out_stream << ReferenceCounter::get_info();
}

template<typename T >

void libMesh::LinearSolver< T >::restrict_solve_to	(	const std::vector< unsigned int > *const	dofs,
		const SubsetSolveMode	subset_solve_mode = SUBSET_ZERO
	)			[inline, virtual, inherited]

After calling this method, all successive solves will be restricted to the given set of dofs, which must contain local dofs on each processor only and not contain any duplicates. This mode can be disabled by calling this method with dofs being a NULL pointer.

Reimplemented in libMesh::PetscLinearSolver< T >.

Definition at line 126 of file linear_solver.C.

{
  if(dofs!=NULL)
    {
      libmesh_not_implemented();
    }
}

template<typename T >

void libMesh::LinearSolver< T >::reuse_preconditioner

(

bool

reuse_flag

)

[inline, virtual, inherited]

Definition at line 119 of file linear_solver.C.

References libMesh::LinearSolver< T >::same_preconditioner.

Referenced by libMesh::ImplicitSystem::disable_cache().

  {
    same_preconditioner = reuse_flag;
  }

template<typename T >

void libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type

(

)

[inline, private]

Tells LASPACK to use the user-specified preconditioner stored in _preconditioner_type

Definition at line 489 of file laspack_linear_solver.C.

References libMesh::LaspackLinearSolver< T >::_precond_type, libMesh::LinearSolver< T >::_preconditioner_type, libMesh::err, libMeshEnums::IDENTITY_PRECOND, libMeshEnums::ILU_PRECOND, libMeshEnums::JACOBI_PRECOND, and libMeshEnums::SSOR_PRECOND.

Referenced by libMesh::LaspackLinearSolver< T >::adjoint_solve(), and libMesh::LaspackLinearSolver< T >::solve().

{
  switch (this->_preconditioner_type)
    {
    case IDENTITY_PRECOND:
      _precond_type = NULL; return;

    case ILU_PRECOND:
      _precond_type = ILUPrecond; return;

    case JACOBI_PRECOND:
      _precond_type = JacobiPrecond; return;

    case SSOR_PRECOND:
      _precond_type = SSORPrecond; return;


    default:
      libMesh::err << "ERROR:  Unsupported LASPACK Preconditioner: "
                    << this->_preconditioner_type << std::endl
                    << "Continuing with ILU"      << std::endl;
      this->_preconditioner_type = ILU_PRECOND;
      this->set_laspack_preconditioner_type();
    }
}

template<typename T >

void libMesh::LinearSolver< T >::set_preconditioner_type

(

const PreconditionerType

pct

)

[inline, inherited]

Sets the type of preconditioner to use.

Definition at line 95 of file linear_solver.C.

References libMesh::LinearSolver< T >::_preconditioner, and libMesh::LinearSolver< T >::_preconditioner_type.

{
  if(_preconditioner)
    _preconditioner->set_type(pct);
  else
    _preconditioner_type = pct;
}

template<typename T>

void libMesh::LinearSolver< T >::set_solver_type

(

const SolverType

st

)

[inline, inherited]

Sets the type of solver to use.

Definition at line 101 of file linear_solver.h.

  { _solver_type = st; }

template<typename T>

std::pair< unsigned int, Real > libMesh::LinearSolver< T >::solve	(	const ShellMatrix< T > &	matrix,
		const SparseMatrix< T > *	precond_matrix,
		NumericVector< T > &	sol,
		NumericVector< T > &	rhs,
		const double	tol,
		const unsigned int	n_iter
	)			[inline, inherited]

This function solves a system whose matrix is a shell matrix, but an optional sparse matrix may be used as preconditioning matrix.

Definition at line 310 of file linear_solver.h.

References libMesh::LinearSolver< T >::solve().

{
  if (pc_mat)
    return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
  else
    return this->solve(mat, sol, rhs, tol, n_iter);
}

template<typename T>

std::pair< unsigned int, Real > libMesh::LinearSolver< T >::solve	(	SparseMatrix< T > &	matrix,
		SparseMatrix< T > *	precond_matrix,
		NumericVector< T > &	sol,
		NumericVector< T > &	rhs,
		const double	tol,
		const unsigned int	n_iter
	)			[inline, inherited]

This function calls the solver "_solver_type" preconditioned with the "_preconditioner_type" preconditioner. The preconditioning matrix is used if it is provided, or the system matrix is used if precond_matrix is null

Definition at line 293 of file linear_solver.h.

References libMesh::LinearSolver< T >::solve().

{
  if (pc_mat)
    return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
  else
    return this->solve(mat, sol, rhs, tol, n_iter);
}

template<typename T >

std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::solve	(	const ShellMatrix< T > &	shell_matrix,
		const SparseMatrix< T > &	precond_matrix,
		NumericVector< T > &	solution_in,
		NumericVector< T > &	rhs_in,
		const double	tol,
		const unsigned int	m_its
	)			[inline, virtual]

This function solves a system whose matrix is a shell matrix, but a sparse matrix is used as preconditioning matrix, this allowing other preconditioners than JACOBI.

Implements libMesh::LinearSolver< T >.

Definition at line 475 of file laspack_linear_solver.C.

{
  libmesh_not_implemented();
  return std::make_pair(0,0.0);
}

template<typename T >

std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::solve	(	const ShellMatrix< T > &	shell_matrix,
		NumericVector< T > &	solution_in,
		NumericVector< T > &	rhs_in,
		const double	tol,
		const unsigned int	m_its
	)			[inline, virtual]

This function solves a system whose matrix is a shell matrix.

Implements libMesh::LinearSolver< T >.

Definition at line 461 of file laspack_linear_solver.C.

{
  libmesh_not_implemented();
  return std::make_pair(0,0.0);
}

template<typename T >

std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::solve	(	SparseMatrix< T > &	matrix,
		SparseMatrix< T > &	pc,
		NumericVector< T > &	solution,
		NumericVector< T > &	rhs,
		const double	tol,
		const unsigned int	m_its
	)			[inline, virtual]

Call the Laspack solver

Implements libMesh::LinearSolver< T >.

Definition at line 173 of file laspack_linear_solver.h.

References libMesh::err.

{
  libMesh::err << "ERROR: LASPACK does not support a user-supplied preconditioner!"
                << std::endl;
  libmesh_error();

  std::pair<unsigned int, Real> p;
  return p;
}

template<typename T >

std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::solve	(	SparseMatrix< T > &	matrix,
		NumericVector< T > &	solution,
		NumericVector< T > &	rhs,
		const double	tol,
		const unsigned int	m_its
	)			[inline, virtual]

Call the Laspack solver

Implements libMesh::LinearSolver< T >.

Definition at line 108 of file laspack_linear_solver.C.

References libMesh::LaspackLinearSolver< T >::_precond_type, libMesh::LaspackMatrix< T >::_QMat, libMesh::LinearSolver< T >::_solver_type, libMeshEnums::BICG, libMeshEnums::BICGSTAB, libMeshEnums::CG, libMeshEnums::CGN, libMeshEnums::CGS, libMesh::LaspackMatrix< T >::close(), libMesh::err, libMeshEnums::GMRES, libMesh::LaspackLinearSolver< T >::init(), libMeshEnums::JACOBI, libMeshEnums::QMR, libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type(), and libMeshEnums::SSOR.

Referenced by libMesh::LaspackLinearSolver< T >::adjoint_solve().

{
  START_LOG("solve()", "LaspackLinearSolver");
  this->init ();

  // Make sure the data passed in are really in Laspack types
  LaspackMatrix<T>* matrix   = libmesh_cast_ptr<LaspackMatrix<T>*>(&matrix_in);
  LaspackVector<T>* solution = libmesh_cast_ptr<LaspackVector<T>*>(&solution_in);
  LaspackVector<T>* rhs      = libmesh_cast_ptr<LaspackVector<T>*>(&rhs_in);

  // Zero-out the solution to prevent the solver from exiting in 0
  // iterations (?)
  //TODO:[BSK] Why does Laspack do this?  Comment out this and try ex13...
  solution->zero();

  // Close the matrix and vectors in case this wasn't already done.
  matrix->close ();
  solution->close ();
  rhs->close ();

  // Set the preconditioner type
  this->set_laspack_preconditioner_type ();

  // Set the solver tolerance
  SetRTCAccuracy (tol);

  // Solve the linear system
  switch (this->_solver_type)
    {
      // Conjugate-Gradient
    case CG:
      {
        CGIter (&matrix->_QMat,
                &solution->_vec,
                &rhs->_vec,
                m_its,
                _precond_type,
                1.);
        break;
      }

      // Conjugate-Gradient Normalized
    case CGN:
      {
        CGNIter (&matrix->_QMat,
                 &solution->_vec,
                 &rhs->_vec,
                 m_its,
                 _precond_type,
                 1.);
        break;
      }

      // Conjugate-Gradient Squared
    case CGS:
      {
        CGSIter (&matrix->_QMat,
                 &solution->_vec,
                 &rhs->_vec,
                 m_its,
                 _precond_type,
                 1.);
        break;
      }

      // Bi-Conjugate Gradient
    case BICG:
      {
        BiCGIter (&matrix->_QMat,
                  &solution->_vec,
                  &rhs->_vec,
                  m_its,
                  _precond_type,
                  1.);
        break;
      }

      // Bi-Conjugate Gradient Stabilized
    case BICGSTAB:
      {
        BiCGSTABIter (&matrix->_QMat,
                      &solution->_vec,
                      &rhs->_vec,
                      m_its,
                      _precond_type,
                      1.);
        break;
      }

      // Quasi-Minimum Residual
    case QMR:
      {
        QMRIter (&matrix->_QMat,
                 &solution->_vec,
                 &rhs->_vec,
                 m_its,
                 _precond_type,
                 1.);
        break;
      }

      // Symmetric over-relaxation
    case SSOR:
      {
        SSORIter (&matrix->_QMat,
                  &solution->_vec,
                  &rhs->_vec,
                  m_its,
                  _precond_type,
                  1.);
        break;
      }

      // Jacobi Relaxation
    case JACOBI:
      {
        JacobiIter (&matrix->_QMat,
                    &solution->_vec,
                    &rhs->_vec,
                    m_its,
                    _precond_type,
                    1.);
        break;
      }

      // Generalized Minimum Residual
    case GMRES:
      {
        SetGMRESRestart (30);
        GMRESIter (&matrix->_QMat,
                   &solution->_vec,
                   &rhs->_vec,
                   m_its,
                   _precond_type,
                   1.);
        break;
      }

      // Unknown solver, use GMRES
    default:
      {
        libMesh::err << "ERROR:  Unsupported LASPACK Solver: "
                      << this->_solver_type      << std::endl
                      << "Continuing with GMRES" << std::endl;

        this->_solver_type = GMRES;

        return this->solve (*matrix,
                            *solution,
                            *rhs,
                            tol,
                            m_its);
      }
    }

  // Check for an error
  if (LASResult() != LASOK)
    {
      libMesh::err << "ERROR:  LASPACK Error: " << std::endl;
      WriteLASErrDescr(stdout);
      libmesh_error();
    }

  STOP_LOG("solve()", "LaspackLinearSolver");
  // Get the convergence step # and residual
  return std::make_pair(GetLastNoIter(), GetLastAccuracy());
}

template<typename T>

SolverType libMesh::LinearSolver< T >::solver_type

(

)

const [inline, inherited]

Returns the type of solver to use.

Definition at line 96 of file linear_solver.h.

{ return _solver_type; }

---

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 118 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited]

Flag to control whether reference count information is printed when print_info is called.

Definition at line 137 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

template<typename T>

bool libMesh::LinearSolver< T >::_is_initialized [protected, inherited]

Flag indicating if the data structures have been initialized.

Definition at line 242 of file linear_solver.h.

Referenced by libMesh::LinearSolver< T >::attach_preconditioner(), libMesh::AztecLinearSolver< T >::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::LaspackLinearSolver< T >::clear(), libMesh::AztecLinearSolver< T >::init(), libMesh::PetscLinearSolver< T >::init(), libMesh::LaspackLinearSolver< T >::init(), and libMesh::LinearSolver< Number >::initialized().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 of file reference_counter.h.

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 126 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

template<typename T >

PrecondProcType libMesh::LaspackLinearSolver< T >::_precond_type [private]

Preconditioner type

Definition at line 147 of file laspack_linear_solver.h.

Referenced by libMesh::LaspackLinearSolver< T >::adjoint_solve(), libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type(), and libMesh::LaspackLinearSolver< T >::solve().

template<typename T>

Preconditioner<T>* libMesh::LinearSolver< T >::_preconditioner [protected, inherited]

Holds the Preconditioner object to be used for the linear solves.

Definition at line 247 of file linear_solver.h.

Referenced by libMesh::PetscLinearSolver< T >::adjoint_solve(), libMesh::LinearSolver< T >::attach_preconditioner(), libMesh::PetscLinearSolver< T >::clear(), libMesh::PetscLinearSolver< T >::init(), libMesh::LinearSolver< T >::preconditioner_type(), libMesh::LinearSolver< T >::set_preconditioner_type(), and libMesh::PetscLinearSolver< T >::solve().

template<typename T>

PreconditionerType libMesh::LinearSolver< T >::_preconditioner_type [protected, inherited]

Enum statitng with type of preconditioner to use.

Definition at line 237 of file linear_solver.h.

Referenced by libMesh::LinearSolver< T >::attach_preconditioner(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::AztecLinearSolver< T >::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::LaspackLinearSolver< T >::clear(), libMesh::AztecLinearSolver< T >::init(), libMesh::PetscLinearSolver< T >::init(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::LinearSolver< T >::preconditioner_type(), libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type(), and libMesh::LinearSolver< T >::set_preconditioner_type().

template<typename T>

SolverType libMesh::LinearSolver< T >::_solver_type [protected, inherited]

Enum stating which type of iterative solver to use.

Definition at line 232 of file linear_solver.h.

Referenced by libMesh::LaspackLinearSolver< T >::adjoint_solve(), libMesh::AztecLinearSolver< T >::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::LaspackLinearSolver< T >::clear(), libMesh::PetscLinearSolver< T >::set_petsc_solver_type(), libMesh::AztecLinearSolver< T >::set_solver_type(), libMesh::LinearSolver< Number >::set_solver_type(), libMesh::LaspackLinearSolver< T >::solve(), and libMesh::LinearSolver< Number >::solver_type().

template<typename T>

bool libMesh::LinearSolver< T >::same_preconditioner [protected, inherited]

Boolean flag to indicate whether we want to use an identical preconditioner to the previous solve. This can save substantial work in the cases where the system matrix is the same for successive solves.

Definition at line 255 of file linear_solver.h.

Referenced by libMesh::PetscLinearSolver< T >::adjoint_solve(), libMesh::LinearSolver< T >::get_same_preconditioner(), libMesh::LinearSolver< T >::reuse_preconditioner(), and libMesh::PetscLinearSolver< T >::solve().

---

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

• laspack_linear_solver.h
• laspack_linear_solver.C