libMesh::PetscPreconditioner< T > Class Template Reference

#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) libmesh_override
 
virtual void clear () libmesh_override
 
virtual void init () libmesh_override
 
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::Communicatorcomm () 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. All overridden virtual functions are documented in preconditioner.h.

Author
Derek Gaston
Date
2009

Definition at line 56 of file petsc_preconditioner.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 119 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 123 of file petsc_preconditioner.h.

123  :
124  Preconditioner<T>(comm_in),
125  _pc(PETSC_NULL)
126 {
127 }
template<typename T >
libMesh::PetscPreconditioner< T >::~PetscPreconditioner ( )
inlinevirtual

Destructor.

Definition at line 133 of file petsc_preconditioner.h.

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

134 {
135  this->clear ();
136 }
virtual void clear() libmesh_override

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 vector x. This is usually done by solving $ Py=x $ to get the action of $ P^-1 x $.

Implements libMesh::Preconditioner< T >.

Definition at line 40 of file petsc_preconditioner.C.

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

41 {
42  PetscVector<T> & x_pvec = cast_ref<PetscVector<T> &>(const_cast<NumericVector<T> &>(x));
43  PetscVector<T> & y_pvec = cast_ref<PetscVector<T> &>(const_cast<NumericVector<T> &>(y));
44 
45  Vec x_vec = x_pvec.vec();
46  Vec y_vec = y_pvec.vec();
47 
48  int ierr = PCApply(_pc,x_vec,y_vec);
49  LIBMESH_CHKERR(ierr);
50 }
PetscErrorCode Vec x
PetscErrorCode 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() 
)
staticinherited

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::libmesh_ignore(), libmesh_nullptr, libMesh::PETSC_SOLVERS, and libMesh::TRILINOS_SOLVERS.

40 {
41  // Avoid unused parameter warnings when no solver packages are enabled.
43 
44  // Build the appropriate solver
45  switch (solver_package)
46  {
47 
48 #ifdef LIBMESH_HAVE_PETSC
49  case PETSC_SOLVERS:
50  {
51  return new PetscPreconditioner<T>(comm);
52  }
53 #endif
54 
55 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
56  case TRILINOS_SOLVERS:
57  return new TrilinosPreconditioner<T>(comm);
58 #endif
59 
60 #ifdef LIBMESH_HAVE_EIGEN
61  case EIGEN_SOLVERS:
62  return new EigenPreconditioner<T>(comm);
63 #endif
64 
65  default:
66  libmesh_error_msg("ERROR: Unrecognized solver package: " << solver_package);
67  }
68 
69  return libmesh_nullptr;
70 }
EIGEN_SOLVERS
Definition: libmesh.C:262
TRILINOS_SOLVERS
Definition: libmesh.C:260
const class libmesh_nullptr_t libmesh_nullptr
void libmesh_ignore(const T &)
const Parallel::Communicator & comm() const
template<typename T >
void libMesh::PetscPreconditioner< T >::clear ( )
virtual

Release all memory and clear data structures.

Reimplemented from libMesh::Preconditioner< T >.

Definition at line 101 of file petsc_preconditioner.C.

References ierr.

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

102 {
103  if (_pc)
104  {
105  int ierr = LibMeshPCDestroy(&_pc);
106  LIBMESH_CHKERR(ierr);
107  }
108 }
PetscErrorCode ierr
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::__libmesh_petsc_snes_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::MeshCommunication::broadcast(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::DistributedVector< T >::clone(), libMesh::EigenSparseVector< T >::clone(), libMesh::LaspackVector< T >::clone(), libMesh::EpetraVector< T >::clone(), libMesh::PetscVector< T >::clone(), libMesh::EpetraVector< T >::close(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), 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::MeshTools::create_bounding_box(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::EquationSystems::get_solution(), libMesh::LocationMap< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::TopologyMap::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::DistributedVector< T >::max(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), libMesh::DistributedVector< T >::min(), libMesh::DistributedMesh::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::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::MetisPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::SparseMatrix< T >::print(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::DistributedVector< T >::zero_clone(), libMesh::EigenSparseVector< T >::zero_clone(), libMesh::LaspackVector< T >::zero_clone(), libMesh::EpetraVector< T >::zero_clone(), and libMesh::PetscVector< T >::zero_clone().

88  { return _communicator; }
const Parallel::Communicator & _communicator
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 101 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

102 {
103  _enable_print_counter = true;
104  return;
105 }
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 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
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 185 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

186 {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189 
190  p.first++;
191 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
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 198 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

199 {
200  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
201  std::pair<unsigned int, unsigned int> & p = _counts[name];
202 
203  p.second++;
204 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
template<typename T >
void libMesh::PetscPreconditioner< T >::init ( )
virtual

Initialize data structures if not done so already.

Note
This MUST be called before the preconditioning object is used.

Reimplemented from libMesh::Preconditioner< T >.

Definition at line 56 of file petsc_preconditioner.C.

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

57 {
58  if (!this->_matrix)
59  libmesh_error_msg("ERROR: No matrix set for PetscPreconditioner, but init() called");
60 
61  // Clear the preconditioner in case it has been created in the past
62  if (!this->_is_initialized)
63  {
64  // Should probably use PCReset(), but it's not working at the moment so we'll destroy instead
65  if (_pc)
66  {
67  int ierr = LibMeshPCDestroy(&_pc);
68  LIBMESH_CHKERR(ierr);
69  }
70 
71  int ierr = PCCreate(this->comm().get(),&_pc);
72  LIBMESH_CHKERR(ierr);
73 
74  PetscMatrix<T> * pmatrix = cast_ptr<PetscMatrix<T> *, SparseMatrix<T> >(this->_matrix);
75 
76  _mat = pmatrix->mat();
77  }
78 
79 #if PETSC_RELEASE_LESS_THAN(3,5,0)
80  int ierr = PCSetOperators(_pc,_mat,_mat,SAME_NONZERO_PATTERN);
81 #else
82  int ierr = PCSetOperators(_pc,_mat,_mat);
83 #endif
84  LIBMESH_CHKERR(ierr);
85 
86  // Set the PCType. Note: this used to be done *before* the call to
87  // PCSetOperators(), and only when !_is_initialized, but
88  // 1.) Some preconditioners (those employing sub-preconditioners,
89  // for example) have to call PCSetUp(), and can only do this after
90  // the operators have been set.
91  // 2.) It should be safe to call set_petsc_preconditioner_type()
92  // multiple times.
94 
95  this->_is_initialized = true;
96 }
PreconditionerType _preconditioner_type
static void set_petsc_preconditioner_type(const PreconditionerType &preconditioner_type, PC &pc)
PetscErrorCode ierr
const Parallel::Communicator & comm() const
SparseMatrix< T > * _matrix
template<typename T>
bool libMesh::Preconditioner< T >::initialized ( ) const
inlineinherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 84 of file preconditioner.h.

84 { return _is_initialized; }
static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 93 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::SparsityPattern::Build::parallel_sync(), 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::SparseMatrix< T >::print(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

94  { return cast_int<processor_id_type>(_communicator.size()); }
unsigned int size() const
Definition: parallel.h:722
const Parallel::Communicator & _communicator
template<typename T >
PC libMesh::PetscPreconditioner< T >::pc ( )
inline
Returns
The PETSc PC object. Can be useful for implementing more advanced algorithms.

Definition at line 81 of file petsc_preconditioner.h.

References libMesh::PetscPreconditioner< T >::_pc, and libMesh::PetscPreconditioner< T >::set_petsc_preconditioner_type().

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

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

89 {
91  out_stream << ReferenceCounter::get_info();
92 }
static std::string get_info()
processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 99 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::MeshCommunication::broadcast(), 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::BoundaryInfo::build_node_list_from_side_list(), libMesh::DofMap::build_sparsity(), libMesh::DistributedMesh::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::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), 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::DofMap::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::EquationSystems::get_solution(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MetisPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print_global(), 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::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::MeshTools::weight(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::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::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), 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::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

100  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
unsigned int rank() const
Definition: parallel.h:720
template<typename T >
void libMesh::Preconditioner< T >::set_matrix ( SparseMatrix< Number > &  mat)
inherited

Sets the matrix to be preconditioned.

Definition at line 171 of file preconditioner.h.

References libMesh::Preconditioner< T >::_is_initialized, and libMesh::Preconditioner< T >::_matrix.

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

172 {
173  //If the matrix is changing then we (probably) need to reinitialize.
174  _is_initialized = false;
175  _matrix = &mat;
176 }
SparseMatrix< T > * _matrix
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 114 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, ierr, libMesh::ILU_PRECOND, libMesh::JACOBI_PRECOND, libMesh::LU_PRECOND, libMesh::pc, libMesh::PetscPreconditioner< T >::set_petsc_subpreconditioner_type(), libMesh::SHELL_PRECOND, libMesh::Parallel::Communicator::size(), libMesh::SOR_PRECOND, and libMesh::USER_PRECOND.

Referenced by libMesh::PetscLinearSolver< T >::init(), and libMesh::PetscPreconditioner< T >::pc().

115 {
116  int ierr = 0;
117 
118  // get the communicator from the PETSc object
120  PetscObjectGetComm((PetscObject)pc, & comm);
121  Parallel::Communicator communicator(comm);
122 
123  switch (preconditioner_type)
124  {
125  case IDENTITY_PRECOND:
126  ierr = PCSetType (pc, const_cast<KSPType>(PCNONE));
127  CHKERRABORT(comm,ierr);
128  break;
129 
130  case CHOLESKY_PRECOND:
131  ierr = PCSetType (pc, const_cast<KSPType>(PCCHOLESKY));
132  CHKERRABORT(comm,ierr);
133  break;
134 
135  case ICC_PRECOND:
136  ierr = PCSetType (pc, const_cast<KSPType>(PCICC));
137  CHKERRABORT(comm,ierr);
138  break;
139 
140  case ILU_PRECOND:
141  {
142  // In serial, just set the ILU preconditioner type
143  if (communicator.size())
144  {
145  ierr = PCSetType (pc, const_cast<KSPType>(PCILU));
146  CHKERRABORT(comm,ierr);
147  }
148  else
149  {
150  // But PETSc has no truly parallel ILU, instead you have to set
151  // an actual parallel preconditioner (e.g. block Jacobi) and then
152  // assign ILU sub-preconditioners.
153  ierr = PCSetType (pc, const_cast<KSPType>(PCBJACOBI));
154  CHKERRABORT(comm,ierr);
155 
156  // Set ILU as the sub preconditioner type
158  }
159  break;
160  }
161 
162  case LU_PRECOND:
163  {
164  // In serial, just set the LU preconditioner type
165  if (communicator.size())
166  {
167  ierr = PCSetType (pc, const_cast<KSPType>(PCLU));
168  CHKERRABORT(comm,ierr);
169  }
170  else
171  {
172  // But PETSc has no truly parallel LU, instead you have to set
173  // an actual parallel preconditioner (e.g. block Jacobi) and then
174  // assign LU sub-preconditioners.
175  ierr = PCSetType (pc, const_cast<KSPType>(PCBJACOBI));
176  CHKERRABORT(comm,ierr);
177 
178  // Set ILU as the sub preconditioner type
180  }
181  break;
182  }
183 
184  case ASM_PRECOND:
185  {
186  // In parallel, I think ASM uses ILU by default as the sub-preconditioner...
187  // I tried setting a different sub-preconditioner here, but apparently the matrix
188  // is not in the correct state (at this point) to call PCSetUp().
189  ierr = PCSetType (pc, const_cast<KSPType>(PCASM));
190  CHKERRABORT(comm,ierr);
191  break;
192  }
193 
194  case JACOBI_PRECOND:
195  ierr = PCSetType (pc, const_cast<KSPType>(PCJACOBI));
196  CHKERRABORT(comm,ierr);
197  break;
198 
200  ierr = PCSetType (pc, const_cast<KSPType>(PCBJACOBI));
201  CHKERRABORT(comm,ierr);
202  break;
203 
204  case SOR_PRECOND:
205  ierr = PCSetType (pc, const_cast<KSPType>(PCSOR));
206  CHKERRABORT(comm,ierr);
207  break;
208 
209  case EISENSTAT_PRECOND:
210  ierr = PCSetType (pc, const_cast<KSPType>(PCEISENSTAT));
211  CHKERRABORT(comm,ierr);
212  break;
213 
214  case AMG_PRECOND:
215  ierr = PCSetType (pc, const_cast<KSPType>(PCHYPRE));
216  CHKERRABORT(comm,ierr);
217  break;
218 
219  case USER_PRECOND:
220  ierr = PCSetType (pc, const_cast<KSPType>(PCMAT));
221  CHKERRABORT(comm,ierr);
222  break;
223 
224  case SHELL_PRECOND:
225  ierr = PCSetType (pc, const_cast<KSPType>(PCSHELL));
226  CHKERRABORT(comm,ierr);
227  break;
228 
229  default:
230  libMesh::err << "ERROR: Unsupported PETSC Preconditioner: "
231  << preconditioner_type << std::endl
232  << "Continuing with PETSC defaults" << std::endl;
233  }
234 
235  // Set additional options if we are doing AMG and
236  // HYPRE is available
237 #ifdef LIBMESH_HAVE_PETSC_HYPRE
238  if (preconditioner_type == AMG_PRECOND)
239  {
240  ierr = PCHYPRESetType(pc, "boomeramg");
241  CHKERRABORT(comm,ierr);
242  }
243 #endif
244 
245  // Let the commandline override stuff
246  ierr = PCSetFromOptions(pc);
247  CHKERRABORT(comm,ierr);
248 }
MPI_Comm communicator
Definition: parallel.h:177
static void set_petsc_subpreconditioner_type(PCType type, PC &pc)
OStreamProxy err(std::cerr)
PetscErrorCode ierr
const Parallel::Communicator & comm() const
template<typename T >
static void libMesh::PetscPreconditioner< T >::set_petsc_subpreconditioner_type ( PCType  type,
PC &  pc 
)
staticprivate

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

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

template<typename T >
static void libMesh::PetscPreconditioner< T >::set_petsc_subpreconditioner_type ( const PCType  type,
PC &  pc 
)
staticprivate
template<typename T >
void libMesh::Preconditioner< T >::set_type ( const PreconditionerType  pct)
inherited

Sets the type of preconditioner to use.

Definition at line 180 of file preconditioner.h.

References libMesh::Preconditioner< T >::_is_initialized, and libMesh::Preconditioner< T >::_preconditioner_type.

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

181 {
182  //If the preconditioner type changes we (probably) need to reinitialize.
183  _is_initialized = false;
184  _preconditioner_type = pct;
185 }
PreconditionerType _preconditioner_type
template<typename T>
virtual void libMesh::Preconditioner< T >::setup ( )
inlinevirtualinherited

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

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

Definition at line 110 of file preconditioner.h.

110 {}
template<typename T>
PreconditionerType libMesh::Preconditioner< T >::type ( ) const
inlineinherited
Returns
The type of preconditioner to use.

Definition at line 120 of file preconditioner.h.

120 { return _preconditioner_type; }
PreconditionerType _preconditioner_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 143 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
protectedinherited

Flag indicating if the data structures have been initialized.

Definition at line 143 of file preconditioner.h.

Referenced by libMesh::Preconditioner< Number >::initialized(), libMesh::Preconditioner< T >::set_matrix(), and libMesh::Preconditioner< T >::set_type().

template<typename T >
Mat libMesh::PetscPreconditioner< T >::_mat
protected

PETSc Mat pulled out of the _matrix object during init().

Definition at line 98 of file petsc_preconditioner.h.

template<typename T>
SparseMatrix<T>* libMesh::Preconditioner< T >::_matrix
protectedinherited

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

Definition at line 133 of file preconditioner.h.

Referenced by libMesh::Preconditioner< T >::set_matrix().

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 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 132 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 93 of file petsc_preconditioner.h.

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

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

Enum stating with type of preconditioner to use.

Definition at line 138 of file preconditioner.h.

Referenced by libMesh::Preconditioner< T >::set_type(), and libMesh::Preconditioner< Number >::type().


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