#include <petsc_preconditioner.h>

Inheritance diagram for libMesh::PetscPreconditioner< T >:

Public Member Functions
	PetscPreconditioner (const libMesh::Parallel::Communicator &comm_in LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
virtual	~PetscPreconditioner ()
virtual void	apply (const NumericVector< T > &x, NumericVector< T > &y)
virtual void	clear ()
virtual void	init ()
PC	pc ()
bool	initialized () const
virtual void	setup ()
void	set_matrix (SparseMatrix< Number > &mat)
PreconditionerType	type () const
void	set_type (const PreconditionerType pct)
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
Static Public Member Functions
static void	set_petsc_preconditioner_type (const PreconditionerType &preconditioner_type, PC &pc)
static Preconditioner< T > *	build (const libMesh::Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD, 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
PC	_pc
Mat	_mat
SparseMatrix< T > *	_matrix
PreconditionerType	_preconditioner_type
bool	_is_initialized
const Parallel::Communicator &	_communicator
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex
static bool	_enable_print_counter = true
Static Private Member Functions
static void	set_petsc_subpreconditioner_type (PCType type, PC &pc)
static void	set_petsc_subpreconditioner_type (const PCType type, PC &pc)

Detailed Description

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

This class provides an interface to the suite of preconditioners available from Petsc.

Author:: Derek Gaston, 2009

Definition at line 59 of file petsc_preconditioner.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::PetscPreconditioner< T >::PetscPreconditioner ( const libMesh::Parallel::Communicator &comm_in LIBMESH_CAN_DEFAULT_TO_COMMWORLD ) [inline]

Constructor. Initializes PetscPreconditioner data structures

Definition at line 137 of file petsc_preconditioner.h.

                                                                                       :
  Preconditioner<T>(comm_in),
  _pc(PETSC_NULL)
{
}

template<typename T >

libMesh::PetscPreconditioner< T >::~PetscPreconditioner ( ) [inline, virtual]

Destructor.

Definition at line 147 of file petsc_preconditioner.h.

{
  this->clear ();
}

Member Function Documentation

template<typename T >

void libMesh::PetscPreconditioner< T >::apply	(	const NumericVector< T > &	x,
		NumericVector< T > &	y
	)		`[virtual]`

Computes the preconditioned vector "y" based on input "x". Usually by solving Py=x to get the action of P^-1 x.

Implements libMesh::Preconditioner< T >.

Definition at line 44 of file petsc_preconditioner.C.

References libMesh::ierr, libMesh::PetscVector< T >::vec(), and libMesh::x.

{
  PetscVector<T> & x_pvec = cast_ref<PetscVector<T>&>(const_cast<NumericVector<T>&>(x));
  PetscVector<T> & y_pvec = cast_ref<PetscVector<T>&>(const_cast<NumericVector<T>&>(y));

  Vec x_vec = x_pvec.vec();
  Vec y_vec = y_pvec.vec();

  int ierr = PCApply(_pc,x_vec,y_vec);
  LIBMESH_CHKERRABORT(ierr);
}

template<typename T>

Preconditioner< T > * libMesh::Preconditioner< T >::build	(	const libMesh::Parallel::Communicator &comm	LIBMESH_CAN_DEFAULT_TO_COMMWORLD,
		const SolverPackage	solver_package = `libMesh::default_solver_package()`
	)		`[static, inherited]`

Builds a Preconditioner using the linear solver package specified by solver_package

Definition at line 38 of file preconditioner.C.

References libMesh::EIGEN_SOLVERS, libMesh::PETSC_SOLVERS, and libMesh::TRILINOS_SOLVERS.

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

#ifdef LIBMESH_HAVE_PETSC
    case PETSC_SOLVERS:
      {
        return new PetscPreconditioner<T>(comm);
      }
#endif

#ifdef LIBMESH_HAVE_TRILINOS
    case TRILINOS_SOLVERS:
      return new TrilinosPreconditioner<T>(comm);
#endif

#ifdef LIBMESH_HAVE_EIGEN
    case EIGEN_SOLVERS:
      return new EigenPreconditioner<T>(comm);
#endif

    default:
      libmesh_error_msg("ERROR:  Unrecognized solver package: " << solver_package);
    }

  return NULL;
}

template<typename T >

void libMesh::PetscPreconditioner< T >::clear ( ) [virtual]

Release all memory and clear data structures.

Reimplemented from libMesh::Preconditioner< T >.

Definition at line 105 of file petsc_preconditioner.C.

References libMesh::ierr.

{
  if (_pc)
    {
      int ierr = LibMeshPCDestroy(&_pc);
      LIBMESH_CHKERRABORT(ierr);
    }
}

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const [inline, inherited]

Returns:: a reference to the Parallel::Communicator object used by this mesh.

Definition at line 86 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

  { return _communicator; }

void libMesh::ReferenceCounter::disable_print_counter_info ( ) [static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::LibMeshInit().

{
  _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
}

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, libMesh::Quality::name(), 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, libMesh::Quality::name(), 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::PetscPreconditioner< T >::init ( ) [virtual]

Initialize data structures if not done so already.

Reimplemented from libMesh::Preconditioner< T >.

Definition at line 60 of file petsc_preconditioner.C.

References libMesh::libMeshPrivateData::_is_initialized, libMesh::ierr, and libMesh::PetscMatrix< T >::mat().

{
  if(!this->_matrix)
    libmesh_error_msg("ERROR: No matrix set for PetscPreconditioner, but init() called");

  // Clear the preconditioner in case it has been created in the past
  if (!this->_is_initialized)
    {
      // Should probably use PCReset(), but it's not working at the moment so we'll destroy instead
      if (_pc)
        {
          int ierr = LibMeshPCDestroy(&_pc);
          LIBMESH_CHKERRABORT(ierr);
        }

      int ierr = PCCreate(this->comm().get(),&_pc);
      LIBMESH_CHKERRABORT(ierr);

      PetscMatrix<T> * pmatrix = cast_ptr<PetscMatrix<T>*, SparseMatrix<T> >(this->_matrix);

      _mat = pmatrix->mat();
    }

#if PETSC_RELEASE_LESS_THAN(3,5,0)
  int ierr = PCSetOperators(_pc,_mat,_mat,SAME_NONZERO_PATTERN);
#else
  int ierr = PCSetOperators(_pc,_mat,_mat);
#endif
  LIBMESH_CHKERRABORT(ierr);

  // Set the PCType.  Note: this used to be done *before* the call to
  // PCSetOperators(), and only when !_is_initialized, but
  // 1.) Some preconditioners (those employing sub-preconditioners,
  // for example) have to call PCSetUp(), and can only do this after
  // the operators have been set.
  // 2.) It should be safe to call set_petsc_preconditioner_type()
  // multiple times.
  set_petsc_preconditioner_type(this->_preconditioner_type, _pc);

  this->_is_initialized = true;
}

template<typename T>

bool libMesh::Preconditioner< T >::initialized ( ) const [inline, inherited]

Returns:: true if the data structures are initialized, false otherwise.

Definition at line 88 of file preconditioner.h.

{ 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.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

  { return _n_objects; }

processor_id_type libMesh::ParallelObject::n_processors ( ) const [inline, inherited]

Returns:: the number of processors in the group.

Definition at line 92 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

  { return cast_int<processor_id_type>(_communicator.size()); }

template<typename T >

PC libMesh::PetscPreconditioner< T >::pc ( ) [inline]

Returns the actual Petsc PC struct. Useful for more advanced purposes

Definition at line 94 of file petsc_preconditioner.h.

References libMesh::PetscPreconditioner< T >::_pc.

{ return _pc; }

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().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

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

processor_id_type libMesh::ParallelObject::processor_id ( ) const [inline, inherited]

Returns:: the rank of this processor in the group.

Definition at line 98 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

  { return cast_int<processor_id_type>(_communicator.rank()); }

template<typename T >

void libMesh::Preconditioner< T >::set_matrix ( SparseMatrix< Number > & mat ) [inherited]

Sets the matrix P to be preconditioned.

Definition at line 175 of file preconditioner.h.

References libMesh::libMeshPrivateData::_is_initialized.

{
  //If the matrix is changing then we (probably) need to reinitialize.
  _is_initialized = false;
  _matrix = &mat;
}

template<typename T >

void libMesh::PetscPreconditioner< T >::set_petsc_preconditioner_type	(	const PreconditionerType &	preconditioner_type,
		PC &	pc
	)		`[static]`

Tells PETSC to use the user-specified preconditioner

Definition at line 118 of file petsc_preconditioner.C.

References libMesh::AMG_PRECOND, libMesh::ASM_PRECOND, libMesh::BLOCK_JACOBI_PRECOND, libMesh::CHOLESKY_PRECOND, libMesh::EISENSTAT_PRECOND, libMesh::err, libMesh::ICC_PRECOND, libMesh::IDENTITY_PRECOND, libMesh::ierr, libMesh::ILU_PRECOND, libMesh::JACOBI_PRECOND, libMesh::LU_PRECOND, libMesh::SHELL_PRECOND, libMesh::Parallel::Communicator::size(), libMesh::SOR_PRECOND, and libMesh::USER_PRECOND.

Referenced by libMesh::PetscLinearSolver< T >::init().

{
  int ierr = 0;

  // get the communicator from the PETSc object
  Parallel::communicator comm;
  PetscObjectGetComm((PetscObject)pc, &comm);
  Parallel::Communicator communicator(comm);

  switch (preconditioner_type)
    {
    case IDENTITY_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCNONE));
      CHKERRABORT(comm,ierr);
      break;

    case CHOLESKY_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCCHOLESKY));
      CHKERRABORT(comm,ierr);
      break;

    case ICC_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCICC));
      CHKERRABORT(comm,ierr);
      break;

    case ILU_PRECOND:
      {
        // In serial, just set the ILU preconditioner type
        if (communicator.size())
          {
            ierr = PCSetType (pc, const_cast<KSPType>(PCILU));
            CHKERRABORT(comm,ierr);
          }
        else
          {
            // But PETSc has no truly parallel ILU, instead you have to set
            // an actual parallel preconditioner (e.g. block Jacobi) and then
            // assign ILU sub-preconditioners.
            ierr = PCSetType (pc, const_cast<KSPType>(PCBJACOBI));
            CHKERRABORT(comm,ierr);

            // Set ILU as the sub preconditioner type
            set_petsc_subpreconditioner_type(PCILU, pc);
          }
        break;
      }

    case LU_PRECOND:
      {
        // In serial, just set the LU preconditioner type
        if (communicator.size())
          {
            ierr = PCSetType (pc, const_cast<KSPType>(PCLU));
            CHKERRABORT(comm,ierr);
          }
        else
          {
            // But PETSc has no truly parallel LU, instead you have to set
            // an actual parallel preconditioner (e.g. block Jacobi) and then
            // assign LU sub-preconditioners.
            ierr = PCSetType (pc, const_cast<KSPType>(PCBJACOBI));
            CHKERRABORT(comm,ierr);

            // Set ILU as the sub preconditioner type
            set_petsc_subpreconditioner_type(PCLU, pc);
          }
        break;
      }

    case ASM_PRECOND:
      {
        // In parallel, I think ASM uses ILU by default as the sub-preconditioner...
        // I tried setting a different sub-preconditioner here, but apparently the matrix
        // is not in the correct state (at this point) to call PCSetUp().
        ierr = PCSetType (pc, const_cast<KSPType>(PCASM));
        CHKERRABORT(comm,ierr);
        break;
      }

    case JACOBI_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCJACOBI));
      CHKERRABORT(comm,ierr);
      break;

    case BLOCK_JACOBI_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCBJACOBI));
      CHKERRABORT(comm,ierr);
      break;

    case SOR_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCSOR));
      CHKERRABORT(comm,ierr);
      break;

    case EISENSTAT_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCEISENSTAT));
      CHKERRABORT(comm,ierr);
      break;

    case AMG_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCHYPRE));
      CHKERRABORT(comm,ierr);
      break;

#if !(PETSC_VERSION_LESS_THAN(2,1,2))
      // Only available for PETSC >= 2.1.2
    case USER_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCMAT));
      CHKERRABORT(comm,ierr);
      break;
#endif

    case SHELL_PRECOND:
      ierr = PCSetType (pc, const_cast<KSPType>(PCSHELL));
      CHKERRABORT(comm,ierr);
      break;

    default:
      libMesh::err << "ERROR:  Unsupported PETSC Preconditioner: "
                   << preconditioner_type       << std::endl
                   << "Continuing with PETSC defaults" << std::endl;
    }

  // Set additional options if we are doing AMG and
  // HYPRE is available
#ifdef LIBMESH_HAVE_PETSC_HYPRE
  if (preconditioner_type == AMG_PRECOND)
    {
      ierr = PCHYPRESetType(pc, "boomeramg");
      CHKERRABORT(comm,ierr);
    }
#endif

  // Let the commandline override stuff
  // FIXME: Unless we are doing AMG???
  if (preconditioner_type != AMG_PRECOND)
    {
      ierr = PCSetFromOptions(pc);
      CHKERRABORT(comm,ierr);
    }
}

template<typename T >

void libMesh::PetscPreconditioner< T >::set_petsc_subpreconditioner_type	(	PCType	type,
		PC &	pc
	)		`[static, private]`

Some PETSc preconditioners (ILU, LU) don't work in parallel. This function is called from set_petsc_preconditioner_type() to set additional options for those so-called sub-preconditioners. This method ends up being static so that it can be called from set_petsc_preconditioner_type(). Not sure why set_petsc_preconditioner_type() needs to be static though...

Definition at line 265 of file petsc_preconditioner.C.

References libMesh::ierr, and libMesh::PC().

{
  // For catching PETSc error return codes
  int ierr = 0;

  // get the communicator from the PETSc object
  Parallel::communicator comm;
  PetscObjectGetComm((PetscObject)pc, &comm);
  Parallel::Communicator communicator(comm);

  // All docs say must call KSPSetUp or PCSetUp before calling PCBJacobiGetSubKSP.
  // You must call PCSetUp after the preconditioner operators have been set, otherwise you get the:
  //
  // "Object is in wrong state!"
  // "Matrix must be set first."
  //
  // error messages...
  ierr = PCSetUp(pc);
  CHKERRABORT(comm,ierr);

  // To store array of local KSP contexts on this processor
  KSP* subksps;

  // the number of blocks on this processor
  PetscInt n_local;

  // The global number of the first block on this processor.
  // This is not used, so we just pass PETSC_NULL instead.
  // int first_local;

  // Fill array of local KSP contexts
  ierr = PCBJacobiGetSubKSP(pc, &n_local, PETSC_NULL, &subksps);
  CHKERRABORT(comm,ierr);

  // Loop over sub-ksp objects, set ILU preconditioner
  for (PetscInt i=0; i<n_local; ++i)
    {
      // Get pointer to sub KSP object's PC
      PC subpc;
      ierr = KSPGetPC(subksps[i], &subpc);
      CHKERRABORT(comm,ierr);

      // Set requested type on the sub PC
      ierr = PCSetType(subpc, type);
      CHKERRABORT(comm,ierr);
    }

}

template<typename T >

static void libMesh::PetscPreconditioner< T >::set_petsc_subpreconditioner_type	(	const PCType	type,
		PC &	pc
	)		`[static, private]`

template<typename T >

void libMesh::Preconditioner< T >::set_type ( const PreconditionerType pct ) [inherited]

Sets the type of preconditioner to use.

Definition at line 184 of file preconditioner.h.

References libMesh::libMeshPrivateData::_is_initialized.

{
  //If the preconditioner type changes we (probably) need to reinitialize.
  _is_initialized = false;
  _preconditioner_type = pct;
}

template<typename T>

virtual void libMesh::Preconditioner< T >::setup ( ) [inline, virtual, inherited]

This is called every time the "operator might have changed".

This is essentially where you need to fill in your preconditioning matrix.

Definition at line 113 of file preconditioner.h.

{}

template<typename T>

PreconditionerType libMesh::Preconditioner< T >::type ( ) const [inline, inherited]

Returns the type of preconditioner to use.

Definition at line 123 of file preconditioner.h.

  { return _preconditioner_type; }

Member Data Documentation

const Parallel::Communicator& libMesh::ParallelObject::_communicator [protected, inherited]

Definition at line 104 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_solution_vector(), libMesh::ParallelObject::comm(), libMesh::EquationSystems::get_solution(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

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::Preconditioner< T >::_is_initialized [protected, inherited]

Flag indicating if the data structures have been initialized.

Definition at line 147 of file preconditioner.h.

Referenced by libMesh::Preconditioner< Number >::initialized().

template<typename T >

Mat libMesh::PetscPreconditioner< T >::_mat [protected]

Petsc Matrix that's been pulled out of the _matrix object. This happens during init...

Definition at line 112 of file petsc_preconditioner.h.

template<typename T>

SparseMatrix<T>* libMesh::Preconditioner< T >::_matrix [protected, inherited]

The matrix P... ie the matrix to be preconditioned. This is often the actual system matrix of a linear sytem.

Definition at line 137 of file preconditioner.h.

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 >

PC libMesh::PetscPreconditioner< T >::_pc [protected]

Preconditioner context

Definition at line 106 of file petsc_preconditioner.h.

Referenced by libMesh::PetscPreconditioner< T >::pc().

template<typename T>

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

Enum statitng with type of preconditioner to use.

Definition at line 142 of file preconditioner.h.

Referenced by libMesh::Preconditioner< Number >::type().

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

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Static Private Member Functions

Detailed Description

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

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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