libMesh::LaspackLinearSolver< T > Class Template Reference

#include <laspack_linear_solver.h>

Inheritance diagram for libMesh::LaspackLinearSolver< T >:

Public Member Functions

 LaspackLinearSolver (const libMesh::Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
 
 ~LaspackLinearSolver ()
 
void clear ()
 
void init ()
 
std::pair< unsigned int, Realsolve (SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its)
 
std::pair< unsigned int, Realadjoint_solve (SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its)
 
std::pair< unsigned int, Realsolve (SparseMatrix< T > &matrix, SparseMatrix< T > &pc, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its)
 
std::pair< unsigned int, Realsolve (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, Realsolve (SparseMatrix< T > &matrix, SparseMatrix< T > *precond_matrix, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int)
 
std::pair< unsigned int, Realsolve (const ShellMatrix< T > &matrix, const SparseMatrix< T > *precond_matrix, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int)
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static AutoPtr< LinearSolver< T > > build (const libMesh::Parallel::Communicator &comm_in, 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
 
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
 

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
protectedinherited

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 ( const libMesh::Parallel::Communicator &comm  LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
inline

Constructor. Initializes Laspack data structures

Definition at line 155 of file laspack_linear_solver.h.

155  :
156  LinearSolver<T>(comm),
157  _precond_type (ILUPrecond)
158 {
159 }
template<typename T >
libMesh::LaspackLinearSolver< T >::~LaspackLinearSolver ( )
inline

Destructor.

Definition at line 165 of file laspack_linear_solver.h.

166 {
167  this->clear ();
168 }

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 
)
virtual

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

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 285 of file laspack_linear_solver.C.

References libMesh::LaspackMatrix< T >::_QMat, libMeshEnums::BICG, libMeshEnums::BICGSTAB, libMeshEnums::CG, libMeshEnums::CGN, libMeshEnums::CGS, libMesh::LaspackMatrix< T >::close(), libMesh::Utility::enum_to_string(), libMesh::err, libMeshEnums::GMRES, libMesh::TriangleWrapper::init(), libMeshEnums::JACOBI, libMeshEnums::QMR, libMeshEnums::SSOR, libMesh::START_LOG(), libMesh::STOP_LOG(), and libMesh::LaspackVector< T >::zero().

290 {
291  START_LOG("adjoint_solve()", "LaspackLinearSolver");
292  this->init ();
293 
294  // Make sure the data passed in are really in Laspack types
295  LaspackMatrix<T>* matrix = libmesh_cast_ptr<LaspackMatrix<T>*>(&matrix_in);
296  LaspackVector<T>* solution = libmesh_cast_ptr<LaspackVector<T>*>(&solution_in);
297  LaspackVector<T>* rhs = libmesh_cast_ptr<LaspackVector<T>*>(&rhs_in);
298 
299  // Zero-out the solution to prevent the solver from exiting in 0
300  // iterations (?)
301  //TODO:[BSK] Why does Laspack do this? Comment out this and try ex13...
302  solution->zero();
303 
304  // Close the matrix and vectors in case this wasn't already done.
305  matrix->close ();
306  solution->close ();
307  rhs->close ();
308 
309  // Set the preconditioner type
311 
312  // Set the solver tolerance
313  SetRTCAccuracy (tol);
314 
315  // Solve the linear system
316  switch (this->_solver_type)
317  {
318  // Conjugate-Gradient
319  case CG:
320  {
321  CGIter (Transp_Q(&matrix->_QMat),
322  &solution->_vec,
323  &rhs->_vec,
324  m_its,
326  1.);
327  break;
328  }
329 
330  // Conjugate-Gradient Normalized
331  case CGN:
332  {
333  CGNIter (Transp_Q(&matrix->_QMat),
334  &solution->_vec,
335  &rhs->_vec,
336  m_its,
338  1.);
339  break;
340  }
341 
342  // Conjugate-Gradient Squared
343  case CGS:
344  {
345  CGSIter (Transp_Q(&matrix->_QMat),
346  &solution->_vec,
347  &rhs->_vec,
348  m_its,
350  1.);
351  break;
352  }
353 
354  // Bi-Conjugate Gradient
355  case BICG:
356  {
357  BiCGIter (Transp_Q(&matrix->_QMat),
358  &solution->_vec,
359  &rhs->_vec,
360  m_its,
362  1.);
363  break;
364  }
365 
366  // Bi-Conjugate Gradient Stabilized
367  case BICGSTAB:
368  {
369  BiCGSTABIter (Transp_Q(&matrix->_QMat),
370  &solution->_vec,
371  &rhs->_vec,
372  m_its,
374  1.);
375  break;
376  }
377 
378  // Quasi-Minimum Residual
379  case QMR:
380  {
381  QMRIter (Transp_Q(&matrix->_QMat),
382  &solution->_vec,
383  &rhs->_vec,
384  m_its,
386  1.);
387  break;
388  }
389 
390  // Symmetric over-relaxation
391  case SSOR:
392  {
393  SSORIter (Transp_Q(&matrix->_QMat),
394  &solution->_vec,
395  &rhs->_vec,
396  m_its,
398  1.);
399  break;
400  }
401 
402  // Jacobi Relaxation
403  case JACOBI:
404  {
405  JacobiIter (Transp_Q(&matrix->_QMat),
406  &solution->_vec,
407  &rhs->_vec,
408  m_its,
410  1.);
411  break;
412  }
413 
414  // Generalized Minimum Residual
415  case GMRES:
416  {
417  SetGMRESRestart (30);
418  GMRESIter (Transp_Q(&matrix->_QMat),
419  &solution->_vec,
420  &rhs->_vec,
421  m_its,
423  1.);
424  break;
425  }
426 
427  // Unknown solver, use GMRES
428  default:
429  {
430  libMesh::err << "ERROR: Unsupported LASPACK Solver: "
431  << Utility::enum_to_string(this->_solver_type) << std::endl
432  << "Continuing with GMRES" << std::endl;
433 
434  this->_solver_type = GMRES;
435 
436  return this->solve (*matrix,
437  *solution,
438  *rhs,
439  tol,
440  m_its);
441  }
442  }
443 
444  // Check for an error
445  if (LASResult() != LASOK)
446  {
447  libMesh::err << "ERROR: LASPACK Error: " << std::endl;
448  WriteLASErrDescr(stdout);
449  libmesh_error();
450  }
451 
452  STOP_LOG("adjoint_solve()", "LaspackLinearSolver");
453  // Get the convergence step # and residual
454  return std::make_pair(GetLastNoIter(), GetLastAccuracy());
455 }
template<typename T>
void libMesh::LinearSolver< T >::attach_preconditioner ( Preconditioner< T > *  preconditioner)
inherited

Attaches a Preconditioner object to be used

Definition at line 116 of file linear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized, libMesh::err, and libMeshEnums::SHELL_PRECOND.

117 {
118  if(this->_is_initialized)
119  {
120  libMesh::err<<"Preconditioner must be attached before the solver is initialized!"<<std::endl;
121  libmesh_error();
122  }
123 
125  _preconditioner = preconditioner;
126 }
template<typename T >
AutoPtr< LinearSolver< T > > libMesh::LinearSolver< T >::build ( const libMesh::Parallel::Communicator comm_in,
const SolverPackage  solver_package = libMesh::default_solver_package() 
)
staticinherited

Builds a LinearSolver using the linear solver package specified by solver_package

Definition at line 40 of file linear_solver.C.

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

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

42 {
43  // Build the appropriate solver
44  switch (solver_package)
45  {
46 
47 
48 #ifdef LIBMESH_HAVE_LASPACK
49  case LASPACK_SOLVERS:
50  {
51  AutoPtr<LinearSolver<T> > ap(new LaspackLinearSolver<T>(comm));
52  return ap;
53  }
54 #endif
55 
56 
57 #ifdef LIBMESH_HAVE_PETSC
58  case PETSC_SOLVERS:
59  {
60  AutoPtr<LinearSolver<T> > ap(new PetscLinearSolver<T>(comm));
61  return ap;
62  }
63 #endif
64 
65 
66 #ifdef LIBMESH_HAVE_TRILINOS
67  case TRILINOS_SOLVERS:
68  {
69  AutoPtr<LinearSolver<T> > ap(new AztecLinearSolver<T>(comm));
70  return ap;
71  }
72 #endif
73 
74 
75 #ifdef LIBMESH_HAVE_EIGEN
76  case EIGEN_SOLVERS:
77  {
78  AutoPtr<LinearSolver<T> > ap(new EigenSparseLinearSolver<T>(comm));
79  return ap;
80  }
81 #endif
82 
83  default:
84  libMesh::err << "ERROR: Unrecognized solver package: "
85  << solver_package
86  << std::endl;
87  libmesh_error();
88  }
89 
90  AutoPtr<LinearSolver<T> > ap(NULL);
91  return ap;
92 }
template<typename T >
void libMesh::LaspackLinearSolver< T >::clear ( )
virtual

Release all memory and clear data structures.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 80 of file laspack_linear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized, libMeshEnums::GMRES, libMeshEnums::ILU_PRECOND, and libMesh::initialized().

81 {
82  if (this->initialized())
83  {
84  this->_is_initialized = false;
85 
86  this->_solver_type = GMRES;
88  }
89 }
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
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.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_residual(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::MetisPartitioner::_do_partition(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::ParallelMesh::add_elem(), libMesh::ImplicitSystem::add_matrix(), libMesh::ParallelMesh::add_node(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::bounding_box(), libMesh::System::calculate_norm(), libMesh::MeshRefinement::coarsen_elements(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMLibMeshSetSystem(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::for(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::LocationMap< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_flags(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), libMesh::ParallelMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::ParallelMesh::parallel_max_elem_id(), libMesh::ParallelMesh::parallel_max_node_id(), libMesh::ParallelMesh::parallel_n_elem(), libMesh::ParallelMesh::parallel_n_nodes(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::System::project_vector(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::UnstructuredMesh::write(), libMesh::LegacyXdrIO::write_mesh(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), and libMesh::DivaIO::write_stream().

87  { return _communicator; }
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

107 {
108  _enable_print_counter = false;
109  return;
110 }
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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.

101 {
102  _enable_print_counter = true;
103  return;
104 }
std::string libMesh::ReferenceCounter::get_info ( )
staticinherited

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

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (Counts::iterator it = _counts.begin();
59  it != _counts.end(); ++it)
60  {
61  const std::string name(it->first);
62  const unsigned int creations = it->second.first;
63  const unsigned int destructions = it->second.second;
64 
65  oss << "| " << name << " reference count information:\n"
66  << "| Creations: " << creations << '\n'
67  << "| Destructions: " << destructions << '\n';
68  }
69 
70  oss << " ---------------------------------------------------------------------------- \n";
71 
72  return oss.str();
73 
74 #else
75 
76  return "";
77 
78 #endif
79 }
template<typename T >
bool libMesh::LinearSolver< T >::get_same_preconditioner ( )
inlineinherited

Definition at line 290 of file linear_solver.h.

291 {
292  return same_preconditioner;
293 }
void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
inlineprotectedinherited

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

164 {
165  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
166  std::pair<unsigned int, unsigned int>& p = _counts[name];
167 
168  p.first++;
169 }
void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
inlineprotectedinherited

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

177 {
178  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
179  std::pair<unsigned int, unsigned int>& p = _counts[name];
180 
181  p.second++;
182 }
template<typename T >
void libMesh::LaspackLinearSolver< T >::init ( )
virtual

Initialize data structures if not done so already.

Implements libMesh::LinearSolver< T >.

Definition at line 94 of file laspack_linear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized, and libMesh::initialized().

95 {
96  // Initialize the data structures if not done so already.
97  if (!this->initialized())
98  {
99  this->_is_initialized = true;
100  }
101 
102  // SetRTCAuxProc (print_iter_accuracy);
103 }
template<typename T>
bool libMesh::LinearSolver< T >::initialized ( ) const
inlineinherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 85 of file linear_solver.h.

85 { return _is_initialized; }
static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

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.

80  { return _n_objects; }
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
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().

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::ParallelMesh::add_elem(), libMesh::ParallelMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::ParallelMesh::assign_unique_ids(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::ParallelMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshTools::processor_bounding_box(), libMesh::System::project_vector(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::UnstructuredMesh::read(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::Partitioner::repartition(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::BoundaryInfo::sync(), libMesh::ParallelMesh::update_parallel_id_counts(), libMesh::CheckpointIO::write(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

93  { return libmesh_cast_int<processor_id_type>(_communicator.size()); }
template<typename T >
PreconditionerType libMesh::LinearSolver< T >::preconditioner_type ( ) const
inherited

Returns the type of preconditioner to use.

Definition at line 96 of file linear_solver.C.

97 {
98  if(_preconditioner)
99  return _preconditioner->type();
100 
101  return _preconditioner_type;
102 }
template<typename T >
void libMesh::LaspackLinearSolver< T >::print_converged_reason ( )
virtual

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

Implements libMesh::LinearSolver< T >.

Definition at line 519 of file laspack_linear_solver.C.

References libMesh::out.

520 {
521  libMesh::out << "print_converged_reason() is currently only supported"
522  << "with Petsc 2.3.1 and later." << std::endl;
523 }
void libMesh::ReferenceCounter::print_info ( std::ostream &  out = libMesh::out)
staticinherited

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

89 {
91 }
processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
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().

Referenced by libMesh::MetisPartitioner::_do_partition(), libMesh::EquationSystems::_read_impl(), libMesh::SerialMesh::active_local_elements_begin(), libMesh::ParallelMesh::active_local_elements_begin(), libMesh::SerialMesh::active_local_elements_end(), libMesh::ParallelMesh::active_local_elements_end(), libMesh::SerialMesh::active_local_subdomain_elements_begin(), libMesh::ParallelMesh::active_local_subdomain_elements_begin(), libMesh::SerialMesh::active_local_subdomain_elements_end(), libMesh::ParallelMesh::active_local_subdomain_elements_end(), libMesh::SerialMesh::active_not_local_elements_begin(), libMesh::ParallelMesh::active_not_local_elements_begin(), libMesh::SerialMesh::active_not_local_elements_end(), libMesh::ParallelMesh::active_not_local_elements_end(), libMesh::ParallelMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::ParallelMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::DofMap::build_sparsity(), libMesh::ParallelMesh::clear(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO_Helper::create(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::hessian(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::SerialMesh::local_elements_begin(), libMesh::ParallelMesh::local_elements_begin(), libMesh::SerialMesh::local_elements_end(), libMesh::ParallelMesh::local_elements_end(), libMesh::SerialMesh::local_level_elements_begin(), libMesh::ParallelMesh::local_level_elements_begin(), libMesh::SerialMesh::local_level_elements_end(), libMesh::ParallelMesh::local_level_elements_end(), libMesh::SerialMesh::local_nodes_begin(), libMesh::ParallelMesh::local_nodes_begin(), libMesh::SerialMesh::local_nodes_end(), libMesh::ParallelMesh::local_nodes_end(), libMesh::SerialMesh::local_not_level_elements_begin(), libMesh::ParallelMesh::local_not_level_elements_begin(), libMesh::SerialMesh::local_not_level_elements_end(), libMesh::ParallelMesh::local_not_level_elements_end(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SerialMesh::not_local_elements_begin(), libMesh::ParallelMesh::not_local_elements_begin(), libMesh::SerialMesh::not_local_elements_end(), libMesh::ParallelMesh::not_local_elements_end(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshFunction::operator()(), libMesh::ParallelMesh::ParallelMesh(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::System::project_vector(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::UnstructuredMesh::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::MeshData::read_xdr(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::BoundaryInfo::sync(), libMesh::MeshTools::total_weight(), libMesh::ParallelMesh::update_parallel_id_counts(), libMesh::MeshTools::weight(), libMesh::ExodusII_IO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::UnstructuredMesh::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

99  { return libmesh_cast_int<processor_id_type>(_communicator.rank()); }
template<typename T >
void libMesh::LinearSolver< T >::restrict_solve_to ( const std::vector< unsigned int > *const  dofs,
const SubsetSolveMode  subset_solve_mode = SUBSET_ZERO 
)
virtualinherited

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 137 of file linear_solver.C.

139 {
140  if(dofs!=NULL)
141  {
142  libmesh_not_implemented();
143  }
144 }
template<typename T >
void libMesh::LinearSolver< T >::reuse_preconditioner ( bool  reuse_flag)
virtualinherited

Definition at line 130 of file linear_solver.C.

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

131  {
132  same_preconditioner = reuse_flag;
133  }
template<typename T >
void libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type ( )
private

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

Definition at line 490 of file laspack_linear_solver.C.

References libMesh::err, libMeshEnums::IDENTITY_PRECOND, libMeshEnums::ILU_PRECOND, libMeshEnums::JACOBI_PRECOND, and libMeshEnums::SSOR_PRECOND.

491 {
492  switch (this->_preconditioner_type)
493  {
494  case IDENTITY_PRECOND:
495  _precond_type = NULL; return;
496 
497  case ILU_PRECOND:
498  _precond_type = ILUPrecond; return;
499 
500  case JACOBI_PRECOND:
501  _precond_type = JacobiPrecond; return;
502 
503  case SSOR_PRECOND:
504  _precond_type = SSORPrecond; return;
505 
506 
507  default:
508  libMesh::err << "ERROR: Unsupported LASPACK Preconditioner: "
509  << this->_preconditioner_type << std::endl
510  << "Continuing with ILU" << std::endl;
513  }
514 }
template<typename T >
void libMesh::LinearSolver< T >::set_preconditioner_type ( const PreconditionerType  pct)
inherited

Sets the type of preconditioner to use.

Definition at line 106 of file linear_solver.C.

107 {
108  if(_preconditioner)
109  _preconditioner->set_type(pct);
110  else
111  _preconditioner_type = pct;
112 }
template<typename T>
void libMesh::LinearSolver< T >::set_solver_type ( const SolverType  st)
inlineinherited

Sets the type of solver to use.

Definition at line 105 of file linear_solver.h.

106  { _solver_type = st; }
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 
)
virtual

Call the Laspack solver

Implements libMesh::LinearSolver< T >.

Definition at line 109 of file laspack_linear_solver.C.

References libMesh::LaspackMatrix< T >::_QMat, libMeshEnums::BICG, libMeshEnums::BICGSTAB, libMeshEnums::CG, libMeshEnums::CGN, libMeshEnums::CGS, libMesh::LaspackMatrix< T >::close(), libMesh::Utility::enum_to_string(), libMesh::err, libMeshEnums::GMRES, libMesh::TriangleWrapper::init(), libMeshEnums::JACOBI, libMeshEnums::QMR, libMeshEnums::SSOR, libMesh::START_LOG(), libMesh::STOP_LOG(), and libMesh::LaspackVector< T >::zero().

114 {
115  START_LOG("solve()", "LaspackLinearSolver");
116  this->init ();
117 
118  // Make sure the data passed in are really in Laspack types
119  LaspackMatrix<T>* matrix = libmesh_cast_ptr<LaspackMatrix<T>*>(&matrix_in);
120  LaspackVector<T>* solution = libmesh_cast_ptr<LaspackVector<T>*>(&solution_in);
121  LaspackVector<T>* rhs = libmesh_cast_ptr<LaspackVector<T>*>(&rhs_in);
122 
123  // Zero-out the solution to prevent the solver from exiting in 0
124  // iterations (?)
125  //TODO:[BSK] Why does Laspack do this? Comment out this and try ex13...
126  solution->zero();
127 
128  // Close the matrix and vectors in case this wasn't already done.
129  matrix->close ();
130  solution->close ();
131  rhs->close ();
132 
133  // Set the preconditioner type
135 
136  // Set the solver tolerance
137  SetRTCAccuracy (tol);
138 
139  // Solve the linear system
140  switch (this->_solver_type)
141  {
142  // Conjugate-Gradient
143  case CG:
144  {
145  CGIter (&matrix->_QMat,
146  &solution->_vec,
147  &rhs->_vec,
148  m_its,
150  1.);
151  break;
152  }
153 
154  // Conjugate-Gradient Normalized
155  case CGN:
156  {
157  CGNIter (&matrix->_QMat,
158  &solution->_vec,
159  &rhs->_vec,
160  m_its,
162  1.);
163  break;
164  }
165 
166  // Conjugate-Gradient Squared
167  case CGS:
168  {
169  CGSIter (&matrix->_QMat,
170  &solution->_vec,
171  &rhs->_vec,
172  m_its,
174  1.);
175  break;
176  }
177 
178  // Bi-Conjugate Gradient
179  case BICG:
180  {
181  BiCGIter (&matrix->_QMat,
182  &solution->_vec,
183  &rhs->_vec,
184  m_its,
186  1.);
187  break;
188  }
189 
190  // Bi-Conjugate Gradient Stabilized
191  case BICGSTAB:
192  {
193  BiCGSTABIter (&matrix->_QMat,
194  &solution->_vec,
195  &rhs->_vec,
196  m_its,
198  1.);
199  break;
200  }
201 
202  // Quasi-Minimum Residual
203  case QMR:
204  {
205  QMRIter (&matrix->_QMat,
206  &solution->_vec,
207  &rhs->_vec,
208  m_its,
210  1.);
211  break;
212  }
213 
214  // Symmetric over-relaxation
215  case SSOR:
216  {
217  SSORIter (&matrix->_QMat,
218  &solution->_vec,
219  &rhs->_vec,
220  m_its,
222  1.);
223  break;
224  }
225 
226  // Jacobi Relaxation
227  case JACOBI:
228  {
229  JacobiIter (&matrix->_QMat,
230  &solution->_vec,
231  &rhs->_vec,
232  m_its,
234  1.);
235  break;
236  }
237 
238  // Generalized Minimum Residual
239  case GMRES:
240  {
241  SetGMRESRestart (30);
242  GMRESIter (&matrix->_QMat,
243  &solution->_vec,
244  &rhs->_vec,
245  m_its,
247  1.);
248  break;
249  }
250 
251  // Unknown solver, use GMRES
252  default:
253  {
254  libMesh::err << "ERROR: Unsupported LASPACK Solver: "
255  << Utility::enum_to_string(this->_solver_type) << std::endl
256  << "Continuing with GMRES" << std::endl;
257 
258  this->_solver_type = GMRES;
259 
260  return this->solve (*matrix,
261  *solution,
262  *rhs,
263  tol,
264  m_its);
265  }
266  }
267 
268  // Check for an error
269  if (LASResult() != LASOK)
270  {
271  libMesh::err << "ERROR: LASPACK Error: " << std::endl;
272  WriteLASErrDescr(stdout);
273  libmesh_error();
274  }
275 
276  STOP_LOG("solve()", "LaspackLinearSolver");
277  // Get the convergence step # and residual
278  return std::make_pair(GetLastNoIter(), GetLastAccuracy());
279 }
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 
)
inlinevirtual

Call the Laspack solver

Implements libMesh::LinearSolver< T >.

Definition at line 175 of file laspack_linear_solver.h.

References libMesh::err.

181 {
182  libMesh::err << "ERROR: LASPACK does not support a user-supplied preconditioner!"
183  << std::endl;
184  libmesh_error();
185 
186  std::pair<unsigned int, Real> p;
187  return p;
188 }
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 
)
virtual

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

Implements libMesh::LinearSolver< T >.

Definition at line 462 of file laspack_linear_solver.C.

467 {
468  libmesh_not_implemented();
469  return std::make_pair(0,0.0);
470 }
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 
)
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 476 of file laspack_linear_solver.C.

482 {
483  libmesh_not_implemented();
484  return std::make_pair(0,0.0);
485 }
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 
)
inlineinherited

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 298 of file linear_solver.h.

304 {
305  if (pc_mat)
306  return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
307  else
308  return this->solve(mat, sol, rhs, tol, n_iter);
309 }
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 
)
inlineinherited

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 315 of file linear_solver.h.

321 {
322  if (pc_mat)
323  return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
324  else
325  return this->solve(mat, sol, rhs, tol, n_iter);
326 }
template<typename T>
SolverType libMesh::LinearSolver< T >::solver_type ( ) const
inlineinherited

Returns the type of solver to use.

Definition at line 100 of file linear_solver.h.

100 { return _solver_type; }

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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
protectedinherited

Flag indicating if the data structures have been initialized.

Definition at line 246 of file linear_solver.h.

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

Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

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
staticprotectedinherited

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 148 of file laspack_linear_solver.h.

template<typename T>
Preconditioner<T>* libMesh::LinearSolver< T >::_preconditioner
protectedinherited

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

Definition at line 251 of file linear_solver.h.

template<typename T>
PreconditionerType libMesh::LinearSolver< T >::_preconditioner_type
protectedinherited

Enum statitng with type of preconditioner to use.

Definition at line 241 of file linear_solver.h.

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

template<typename T>
SolverType libMesh::LinearSolver< T >::_solver_type
protectedinherited

Enum stating which type of iterative solver to use.

Definition at line 236 of file linear_solver.h.

Referenced by libMesh::LinearSolver< Number >::set_solver_type(), and libMesh::LinearSolver< Number >::solver_type().

template<typename T>
bool libMesh::LinearSolver< T >::same_preconditioner
protectedinherited

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 259 of file linear_solver.h.


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

Site Created By: libMesh Developers
Last modified: February 07 2014 16:58:01 UTC

Hosted By:
SourceForge.net Logo