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)
 
virtual ~PetscPreconditioner ()
 
virtual void apply (const NumericVector< T > &x, NumericVector< T > &y) override
 
virtual void clear () override
 
virtual void init () 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 std::unique_ptr< Preconditioner< T > > build_preconditioner (const libMesh::Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
 
static Preconditioner< T > * build (const libMesh::Parallel::Communicator &comm, 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 63 of file petsc_preconditioner.h.

Member Typedef Documentation

◆ Counts

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 117 of file reference_counter.h.

Constructor & Destructor Documentation

◆ PetscPreconditioner()

template<typename T >
libMesh::PetscPreconditioner< T >::PetscPreconditioner ( const libMesh::Parallel::Communicator comm_in)
inline

Constructor. Initializes PetscPreconditioner data structures

Definition at line 129 of file petsc_preconditioner.h.

129  :
130  Preconditioner<T>(comm_in),
131  _pc(PETSC_NULL)
132 {
133 }

◆ ~PetscPreconditioner()

template<typename T >
libMesh::PetscPreconditioner< T >::~PetscPreconditioner ( )
inlinevirtual

Destructor.

Definition at line 139 of file petsc_preconditioner.h.

140 {
141  this->clear ();
142 }
virtual void clear() override

Member Function Documentation

◆ apply()

template<typename T >
void libMesh::PetscPreconditioner< T >::apply ( const NumericVector< T > &  x,
NumericVector< T > &  y 
)
overridevirtual

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 41 of file petsc_preconditioner.C.

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

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

◆ build()

template<typename T >
Preconditioner< T > * libMesh::Preconditioner< T >::build ( const libMesh::Parallel::Communicator comm,
const SolverPackage  solver_package = libMesh::default_solver_package() 
)
staticinherited

Builds a Preconditioner using the linear solver package specified by solver_package

Deprecated:
Use build_preconditioner() instead.

Definition at line 84 of file preconditioner.C.

86 {
87  // You should be calling build_preconditioner() instead.
88  libmesh_deprecated();
89 
90  // Call the non-deprecated method
91  std::unique_ptr<Preconditioner<T>> ptr =
93 
94  // Vaya con dios
95  return ptr.release();
96 }
const Parallel::Communicator & comm() const
static std::unique_ptr< Preconditioner< T > > build_preconditioner(const libMesh::Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())

◆ build_preconditioner()

template<typename T >
std::unique_ptr< Preconditioner< T > > libMesh::Preconditioner< T >::build_preconditioner ( const libMesh::Parallel::Communicator comm,
const SolverPackage  solver_package = libMesh::default_solver_package() 
)
staticinherited

Builds a Preconditioner using the linear solver package specified by solver_package, returning the result wrapped in a std::unique_ptr for safety.

Definition at line 46 of file preconditioner.C.

48 {
49  // Avoid unused parameter warnings when no solver packages are enabled.
51 
52  // Build and return the appropriate Preconditioner object.
53  switch (solver_package)
54  {
55 
56 #ifdef LIBMESH_HAVE_PETSC
57  case PETSC_SOLVERS:
58  {
59  return libmesh_make_unique<PetscPreconditioner<T>>(comm);
60  }
61 #endif
62 
63 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
64  case TRILINOS_SOLVERS:
65  return libmesh_make_unique<TrilinosPreconditioner<T>>(comm);
66 #endif
67 
68 #ifdef LIBMESH_HAVE_EIGEN
69  case EIGEN_SOLVERS:
70  return libmesh_make_unique<EigenPreconditioner<T>>(comm);
71 #endif
72 
73  default:
74  libmesh_error_msg("ERROR: Unrecognized solver package: " << solver_package);
75  }
76 }
EIGEN_SOLVERS
Definition: libmesh.C:246
TRILINOS_SOLVERS
Definition: libmesh.C:244
const Parallel::Communicator & comm() const
void libmesh_ignore(const Args &...)

◆ clear()

template<typename T >
void libMesh::PetscPreconditioner< T >::clear ( )
overridevirtual

Release all memory and clear data structures.

Reimplemented from libMesh::Preconditioner< T >.

Definition at line 102 of file petsc_preconditioner.C.

References ierr.

103 {
104  if (_pc)
105  {
106  int ierr = LibMeshPCDestroy(&_pc);
107  LIBMESH_CHKERR(ierr);
108  }
109 }
PetscErrorCode ierr

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 89 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_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::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), 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::MeshRefinement::_smooth_flags(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::PetscDMWrapper::check_section_n_dofs(), 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::ExodusII_IO::copy_elemental_solution(), 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::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), 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::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), 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::FEMSystem::mesh_position_set(), 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::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), 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_helper(), 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::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

90  { return _communicator; }
const Parallel::Communicator & _communicator

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

107 {
108  _enable_print_counter = false;
109  return;
110 }

◆ enable_print_counter_info()

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 }

◆ get_info()

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 (const auto & pr : _counts)
59  {
60  const std::string name(pr.first);
61  const unsigned int creations = pr.second.first;
62  const unsigned int destructions = pr.second.second;
63 
64  oss << "| " << name << " reference count information:\n"
65  << "| Creations: " << creations << '\n'
66  << "| Destructions: " << destructions << '\n';
67  }
68 
69  oss << " ---------------------------------------------------------------------------- \n";
70 
71  return oss.str();
72 
73 #else
74 
75  return "";
76 
77 #endif
78 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42

◆ increment_constructor_count()

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 181 of file reference_counter.h.

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

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

182 {
183  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
184  std::pair<unsigned int, unsigned int> & p = _counts[name];
185 
186  p.first++;
187 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
spin_mutex spin_mtx
Definition: threads.C:29

◆ increment_destructor_count()

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 194 of file reference_counter.h.

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

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

195 {
196  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
197  std::pair<unsigned int, unsigned int> & p = _counts[name];
198 
199  p.second++;
200 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
spin_mutex spin_mtx
Definition: threads.C:29

◆ init()

template<typename T >
void libMesh::PetscPreconditioner< T >::init ( )
overridevirtual

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 57 of file petsc_preconditioner.C.

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

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

◆ initialized()

template<typename T>
bool libMesh::Preconditioner< T >::initialized ( ) const
inlineinherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 106 of file preconditioner.h.

106 { return _is_initialized; }

◆ n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 95 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), 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::EnsightIO::EnsightIO(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), 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::MeshBase::partition(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

96  { return cast_int<processor_id_type>(_communicator.size()); }
processor_id_type size() const
Definition: communicator.h:175
const Parallel::Communicator & _communicator

◆ pc()

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 87 of file petsc_preconditioner.h.

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

◆ print_info()

void libMesh::ReferenceCounter::print_info ( std::ostream &  out = libMesh::out)
staticinherited

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

Definition at line 87 of file reference_counter.C.

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

88 {
90  out_stream << ReferenceCounter::get_info();
91 }
static std::string get_info()

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 101 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::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), 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::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), 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::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::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), 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::DofMap::last_dof(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), 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::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::BoundaryInfo::n_shellface_conds(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), 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::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), 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_helper(), 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::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< T >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::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::System::write_header(), 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::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), 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::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

102  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
processor_id_type rank() const
Definition: communicator.h:173

◆ set_matrix()

template<typename T >
void libMesh::Preconditioner< T >::set_matrix ( SparseMatrix< Number > &  mat)
inherited

Sets the matrix to be preconditioned.

Definition at line 181 of file preconditioner.h.

182 {
183  //If the matrix is changing then we (probably) need to reinitialize.
184  _is_initialized = false;
185  _matrix = &mat;
186 }
SparseMatrix< T > * _matrix

◆ set_petsc_preconditioner_type()

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 115 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::SHELL_PRECOND, libMesh::SOR_PRECOND, and libMesh::USER_PRECOND.

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

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

◆ set_petsc_subpreconditioner_type() [1/2]

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

◆ set_petsc_subpreconditioner_type() [2/2]

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

◆ set_type()

template<typename T >
void libMesh::Preconditioner< T >::set_type ( const PreconditionerType  pct)
inherited

Sets the type of preconditioner to use.

Definition at line 190 of file preconditioner.h.

191 {
192  //If the preconditioner type changes we (probably) need to reinitialize.
193  _is_initialized = false;
194  _preconditioner_type = pct;
195 }
PreconditionerType _preconditioner_type

◆ setup()

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 132 of file preconditioner.h.

132 {}

◆ type()

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

Definition at line 142 of file preconditioner.h.

142 { return _preconditioner_type; }
PreconditionerType _preconditioner_type

Member Data Documentation

◆ _communicator

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

◆ _enable_print_counter

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 141 of file reference_counter.h.

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

◆ _is_initialized

template<typename T>
bool libMesh::Preconditioner< T >::_is_initialized
protectedinherited

Flag indicating if the data structures have been initialized.

Definition at line 165 of file preconditioner.h.

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

◆ _mat

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

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

Definition at line 104 of file petsc_preconditioner.h.

◆ _matrix

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 155 of file preconditioner.h.

◆ _mutex

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

◆ _n_objects

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 130 of file reference_counter.h.

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

◆ _pc

template<typename T >
PC libMesh::PetscPreconditioner< T >::_pc
protected

Preconditioner context

Definition at line 99 of file petsc_preconditioner.h.

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

◆ _preconditioner_type

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

Enum stating with type of preconditioner to use.

Definition at line 160 of file preconditioner.h.

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


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