libMesh::NonlinearImplicitSystem Class Reference

Used for solving nonlinear implicit systems of equations. More...

#include <nonlinear_implicit_system.h>

Inheritance diagram for libMesh::NonlinearImplicitSystem:

Classes

class  ComputeBounds
 
class  ComputeJacobian
 
class  ComputePostCheck
 
class  ComputeResidual
 
class  ComputeResidualandJacobian
 
class  ComputeVectorSubspace
 

Public Types

typedef NonlinearImplicitSystem sys_type
 
typedef ImplicitSystem Parent
 
typedef std::map< std::string, SparseMatrix< Number > * >::iterator matrices_iterator
 
typedef std::map< std::string, SparseMatrix< Number > * >::const_iterator const_matrices_iterator
 
typedef Number(* ValueFunctionPointer) (const Point &p, const Parameters &Parameters, const std::string &sys_name, const std::string &unknown_name)
 
typedef Gradient(* GradientFunctionPointer) (const Point &p, const Parameters &parameters, const std::string &sys_name, const std::string &unknown_name)
 
typedef std::map< std::string, NumericVector< Number > * >::iterator vectors_iterator
 
typedef std::map< std::string, NumericVector< Number > * >::const_iterator const_vectors_iterator
 

Public Member Functions

 NonlinearImplicitSystem (EquationSystems &es, const std::string &name, const unsigned int number)
 
virtual ~NonlinearImplicitSystem ()
 
sys_typesystem ()
 
virtual void clear () libmesh_override
 
virtual void reinit () libmesh_override
 
virtual void solve () libmesh_override
 
virtual std::pair< unsigned int, Realget_linear_solve_parameters () const libmesh_override
 
virtual void assembly (bool get_residual, bool get_jacobian, bool apply_heterogeneous_constraints=false, bool apply_no_constraints=false) libmesh_override
 
virtual std::string system_type () const libmesh_override
 
unsigned int n_nonlinear_iterations () const
 
Real final_nonlinear_residual () const
 
unsigned get_current_nonlinear_iteration_number () const
 
virtual void assemble () libmesh_override
 
virtual void disable_cache () libmesh_override
 
virtual LinearSolver< Number > * get_linear_solver () const
 
virtual void release_linear_solver (LinearSolver< Number > *) const
 
virtual void assemble_residual_derivatives (const ParameterVector &parameters) libmesh_override
 
virtual std::pair< unsigned int, Realsensitivity_solve (const ParameterVector &parameters) libmesh_override
 
virtual std::pair< unsigned int, Realweighted_sensitivity_solve (const ParameterVector &parameters, const ParameterVector &weights) libmesh_override
 
virtual std::pair< unsigned int, Realadjoint_solve (const QoISet &qoi_indices=QoISet()) libmesh_override
 
virtual std::pair< unsigned int, Realweighted_sensitivity_adjoint_solve (const ParameterVector &parameters, const ParameterVector &weights, const QoISet &qoi_indices=QoISet()) libmesh_override
 
virtual void adjoint_qoi_parameter_sensitivity (const QoISet &qoi_indices, const ParameterVector &parameters, SensitivityData &sensitivities) libmesh_override
 
virtual void forward_qoi_parameter_sensitivity (const QoISet &qoi_indices, const ParameterVector &parameters, SensitivityData &sensitivities) libmesh_override
 
virtual void qoi_parameter_hessian (const QoISet &qoi_indices, const ParameterVector &parameters, SensitivityData &hessian) libmesh_override
 
virtual void qoi_parameter_hessian_vector_product (const QoISet &qoi_indices, const ParameterVector &parameters, const ParameterVector &vector, SensitivityData &product) libmesh_override
 
SparseMatrix< Number > & add_matrix (const std::string &mat_name)
 
void remove_matrix (const std::string &mat_name)
 
bool have_matrix (const std::string &mat_name) const
 
const SparseMatrix< Number > * request_matrix (const std::string &mat_name) const
 
SparseMatrix< Number > * request_matrix (const std::string &mat_name)
 
const SparseMatrix< Number > & get_matrix (const std::string &mat_name) const
 
SparseMatrix< Number > & get_matrix (const std::string &mat_name)
 
virtual unsigned int n_matrices () const libmesh_override
 
virtual void assemble_qoi (const QoISet &qoi_indices=QoISet()) libmesh_override
 
virtual void assemble_qoi_derivative (const QoISet &qoi_indices=QoISet(), bool include_liftfunc=true, bool apply_constraints=true) libmesh_override
 
void init ()
 
virtual void reinit_constraints ()
 
bool is_initialized ()
 
virtual void update ()
 
virtual void restrict_solve_to (const SystemSubset *subset, const SubsetSolveMode subset_solve_mode=SUBSET_ZERO)
 
bool is_adjoint_already_solved () const
 
void set_adjoint_already_solved (bool setting)
 
virtual void qoi_parameter_sensitivity (const QoISet &qoi_indices, const ParameterVector &parameters, SensitivityData &sensitivities)
 
virtual bool compare (const System &other_system, const Real threshold, const bool verbose) const
 
const std::string & name () const
 
void project_solution (FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr) const
 
void project_solution (FEMFunctionBase< Number > *f, FEMFunctionBase< Gradient > *g=libmesh_nullptr) const
 
void project_solution (ValueFunctionPointer fptr, GradientFunctionPointer gptr, const Parameters &parameters) const
 
void project_vector (NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
 
void project_vector (NumericVector< Number > &new_vector, FEMFunctionBase< Number > *f, FEMFunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
 
void project_vector (ValueFunctionPointer fptr, GradientFunctionPointer gptr, const Parameters &parameters, NumericVector< Number > &new_vector, int is_adjoint=-1) const
 
void boundary_project_solution (const std::set< boundary_id_type > &b, const std::vector< unsigned int > &variables, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr)
 
void boundary_project_solution (const std::set< boundary_id_type > &b, const std::vector< unsigned int > &variables, ValueFunctionPointer fptr, GradientFunctionPointer gptr, const Parameters &parameters)
 
void boundary_project_vector (const std::set< boundary_id_type > &b, const std::vector< unsigned int > &variables, NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
 
void boundary_project_vector (const std::set< boundary_id_type > &b, const std::vector< unsigned int > &variables, ValueFunctionPointer fptr, GradientFunctionPointer gptr, const Parameters &parameters, NumericVector< Number > &new_vector, int is_adjoint=-1) const
 
unsigned int number () const
 
void update_global_solution (std::vector< Number > &global_soln) const
 
void update_global_solution (std::vector< Number > &global_soln, const processor_id_type dest_proc) const
 
const MeshBaseget_mesh () const
 
MeshBaseget_mesh ()
 
const DofMapget_dof_map () const
 
DofMapget_dof_map ()
 
const EquationSystemsget_equation_systems () const
 
EquationSystemsget_equation_systems ()
 
bool active () const
 
void activate ()
 
void deactivate ()
 
void set_basic_system_only ()
 
vectors_iterator vectors_begin ()
 
const_vectors_iterator vectors_begin () const
 
vectors_iterator vectors_end ()
 
const_vectors_iterator vectors_end () const
 
NumericVector< Number > & add_vector (const std::string &vec_name, const bool projections=true, const ParallelType type=PARALLEL)
 
void remove_vector (const std::string &vec_name)
 
bool & project_solution_on_reinit (void)
 
bool have_vector (const std::string &vec_name) const
 
const NumericVector< Number > * request_vector (const std::string &vec_name) const
 
NumericVector< Number > * request_vector (const std::string &vec_name)
 
const NumericVector< Number > * request_vector (const unsigned int vec_num) const
 
NumericVector< Number > * request_vector (const unsigned int vec_num)
 
const NumericVector< Number > & get_vector (const std::string &vec_name) const
 
NumericVector< Number > & get_vector (const std::string &vec_name)
 
const NumericVector< Number > & get_vector (const unsigned int vec_num) const
 
NumericVector< Number > & get_vector (const unsigned int vec_num)
 
const std::string & vector_name (const unsigned int vec_num) const
 
const std::string & vector_name (const NumericVector< Number > &vec_reference) const
 
void set_vector_as_adjoint (const std::string &vec_name, int qoi_num)
 
int vector_is_adjoint (const std::string &vec_name) const
 
void set_vector_preservation (const std::string &vec_name, bool preserve)
 
bool vector_preservation (const std::string &vec_name) const
 
NumericVector< Number > & add_adjoint_solution (unsigned int i=0)
 
NumericVector< Number > & get_adjoint_solution (unsigned int i=0)
 
const NumericVector< Number > & get_adjoint_solution (unsigned int i=0) const
 
NumericVector< Number > & add_sensitivity_solution (unsigned int i=0)
 
NumericVector< Number > & get_sensitivity_solution (unsigned int i=0)
 
const NumericVector< Number > & get_sensitivity_solution (unsigned int i=0) const
 
NumericVector< Number > & add_weighted_sensitivity_adjoint_solution (unsigned int i=0)
 
NumericVector< Number > & get_weighted_sensitivity_adjoint_solution (unsigned int i=0)
 
const NumericVector< Number > & get_weighted_sensitivity_adjoint_solution (unsigned int i=0) const
 
NumericVector< Number > & add_weighted_sensitivity_solution ()
 
NumericVector< Number > & get_weighted_sensitivity_solution ()
 
const NumericVector< Number > & get_weighted_sensitivity_solution () const
 
NumericVector< Number > & add_adjoint_rhs (unsigned int i=0)
 
NumericVector< Number > & get_adjoint_rhs (unsigned int i=0)
 
const NumericVector< Number > & get_adjoint_rhs (unsigned int i=0) const
 
NumericVector< Number > & add_sensitivity_rhs (unsigned int i=0)
 
NumericVector< Number > & get_sensitivity_rhs (unsigned int i=0)
 
const NumericVector< Number > & get_sensitivity_rhs (unsigned int i=0) const
 
unsigned int n_vectors () const
 
unsigned int n_vars () const
 
unsigned int n_variable_groups () const
 
unsigned int n_components () const
 
dof_id_type n_dofs () const
 
dof_id_type n_active_dofs () const
 
dof_id_type n_constrained_dofs () const
 
dof_id_type n_local_constrained_dofs () const
 
dof_id_type n_local_dofs () const
 
unsigned int add_variable (const std::string &var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=libmesh_nullptr)
 
unsigned int add_variable (const std::string &var, const Order order=FIRST, const FEFamily=LAGRANGE, const std::set< subdomain_id_type > *const active_subdomains=libmesh_nullptr)
 
unsigned int add_variables (const std::vector< std::string > &vars, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=libmesh_nullptr)
 
unsigned int add_variables (const std::vector< std::string > &vars, const Order order=FIRST, const FEFamily=LAGRANGE, const std::set< subdomain_id_type > *const active_subdomains=libmesh_nullptr)
 
const Variablevariable (unsigned int var) const
 
const VariableGroupvariable_group (unsigned int vg) const
 
bool has_variable (const std::string &var) const
 
const std::string & variable_name (const unsigned int i) const
 
unsigned short int variable_number (const std::string &var) const
 
void get_all_variable_numbers (std::vector< unsigned int > &all_variable_numbers) const
 
unsigned int variable_scalar_number (const std::string &var, unsigned int component) const
 
unsigned int variable_scalar_number (unsigned int var_num, unsigned int component) const
 
const FETypevariable_type (const unsigned int i) const
 
const FETypevariable_type (const std::string &var) const
 
bool identify_variable_groups () const
 
void identify_variable_groups (const bool)
 
Real calculate_norm (const NumericVector< Number > &v, unsigned int var, FEMNormType norm_type, std::set< unsigned int > *skip_dimensions=libmesh_nullptr) const
 
Real calculate_norm (const NumericVector< Number > &v, const SystemNorm &norm, std::set< unsigned int > *skip_dimensions=libmesh_nullptr) const
 
void read_header (Xdr &io, const std::string &version, const bool read_header=true, const bool read_additional_data=true, const bool read_legacy_format=false)
 
void read_legacy_data (Xdr &io, const bool read_additional_data=true)
 
template<typename ValType >
void read_serialized_data (Xdr &io, const bool read_additional_data=true)
 
void read_serialized_data (Xdr &io, const bool read_additional_data=true)
 
template<typename InValType >
std::size_t read_serialized_vectors (Xdr &io, const std::vector< NumericVector< Number > * > &vectors) const
 
std::size_t read_serialized_vectors (Xdr &io, const std::vector< NumericVector< Number > * > &vectors) const
 
template<typename InValType >
void read_parallel_data (Xdr &io, const bool read_additional_data)
 
void read_parallel_data (Xdr &io, const bool read_additional_data)
 
void write_header (Xdr &io, const std::string &version, const bool write_additional_data) const
 
void write_serialized_data (Xdr &io, const bool write_additional_data=true) const
 
std::size_t write_serialized_vectors (Xdr &io, const std::vector< const NumericVector< Number > * > &vectors) const
 
void write_parallel_data (Xdr &io, const bool write_additional_data) const
 
std::string get_info () const
 
void attach_init_function (void fptr(EquationSystems &es, const std::string &name))
 
void attach_init_object (Initialization &init)
 
void attach_assemble_function (void fptr(EquationSystems &es, const std::string &name))
 
void attach_assemble_object (Assembly &assemble)
 
void attach_constraint_function (void fptr(EquationSystems &es, const std::string &name))
 
void attach_constraint_object (Constraint &constrain)
 
void attach_QOI_function (void fptr(EquationSystems &es, const std::string &name, const QoISet &qoi_indices))
 
void attach_QOI_object (QOI &qoi)
 
void attach_QOI_derivative (void fptr(EquationSystems &es, const std::string &name, const QoISet &qoi_indices, bool include_liftfunc, bool apply_constraints))
 
void attach_QOI_derivative_object (QOIDerivative &qoi_derivative)
 
virtual void user_initialization ()
 
virtual void user_assembly ()
 
virtual void user_constrain ()
 
virtual void user_QOI (const QoISet &qoi_indices)
 
virtual void user_QOI_derivative (const QoISet &qoi_indices=QoISet(), bool include_liftfunc=true, bool apply_constraints=true)
 
virtual void re_update ()
 
virtual void restrict_vectors ()
 
virtual void prolong_vectors ()
 
Number current_solution (const dof_id_type global_dof_number) const
 
Number point_value (unsigned int var, const Point &p, const bool insist_on_success=true) const
 
Number point_value (unsigned int var, const Point &p, const Elem &e) const
 
Number point_value (unsigned int var, const Point &p, const Elem *e) const
 
Gradient point_gradient (unsigned int var, const Point &p, const bool insist_on_success=true) const
 
Gradient point_gradient (unsigned int var, const Point &p, const Elem &e) const
 
Gradient point_gradient (unsigned int var, const Point &p, const Elem *e) const
 
Tensor point_hessian (unsigned int var, const Point &p, const bool insist_on_success=true) const
 
Tensor point_hessian (unsigned int var, const Point &p, const Elem &e) const
 
Tensor point_hessian (unsigned int var, const Point &p, const Elem *e) const
 
void local_dof_indices (const unsigned int var, std::set< dof_id_type > &var_indices) const
 
void zero_variable (NumericVector< Number > &v, unsigned int var_num) const
 
bool & hide_output ()
 
void projection_matrix (SparseMatrix< Number > &proj_mat) const
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

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

Public Attributes

std::unique_ptr< NonlinearSolver< Number > > nonlinear_solver
 
std::unique_ptr< DiffSolverdiff_solver
 
SparseMatrix< Number > * matrix
 
bool zero_out_matrix_and_rhs
 
NumericVector< Number > * rhs
 
bool assemble_before_solve
 
bool use_fixed_solution
 
int extra_quadrature_order
 
std::unique_ptr< NumericVector< Number > > solution
 
std::unique_ptr< NumericVector< Number > > current_local_solution
 
Real time
 
std::vector< Numberqoi
 

Protected Types

typedef std::map< std::string, std::pair< unsigned int, unsigned int > > Counts
 

Protected Member Functions

void set_solver_parameters ()
 
virtual void init_data () libmesh_override
 
virtual void init_matrices ()
 
void project_vector (NumericVector< Number > &, int is_adjoint=-1) const
 
void project_vector (const NumericVector< Number > &, NumericVector< Number > &, int is_adjoint=-1) const
 
void increment_constructor_count (const std::string &name)
 
void increment_destructor_count (const std::string &name)
 

Protected Attributes

unsigned int _n_nonlinear_iterations
 
Real _final_nonlinear_residual
 
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
 

Detailed Description

Used for solving nonlinear implicit systems of equations.

This class provides a specific system class. It aims at implicit systems, offering nothing more than just the essentials needed to solve a system.

Note
Additional vectors/matrices can be added via parent class interfaces.
Author
Benjamin S. Kirk
Date
2005

Definition at line 49 of file nonlinear_implicit_system.h.

Member Typedef Documentation

typedef std::map<std::string, SparseMatrix<Number> *>::const_iterator libMesh::ImplicitSystem::const_matrices_iterator
inherited

Definition at line 290 of file implicit_system.h.

typedef std::map<std::string, NumericVector<Number> *>::const_iterator libMesh::System::const_vectors_iterator
inherited

Definition at line 735 of file system.h.

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.

typedef Gradient(* libMesh::System::GradientFunctionPointer) (const Point &p, const Parameters &parameters, const std::string &sys_name, const std::string &unknown_name)
inherited

Definition at line 510 of file system.h.

typedef std::map<std::string, SparseMatrix<Number> *>::iterator libMesh::ImplicitSystem::matrices_iterator
inherited

Matrix iterator typedefs.

Definition at line 289 of file implicit_system.h.

The type of the parent.

Definition at line 74 of file nonlinear_implicit_system.h.

typedef Number(* libMesh::System::ValueFunctionPointer) (const Point &p, const Parameters &Parameters, const std::string &sys_name, const std::string &unknown_name)
inherited

Projects arbitrary functions onto the current solution. The function value fptr and its gradient gptr are represented by function pointers. A gradient gptr is only required/used for projecting onto finite element spaces with continuous derivatives.

Definition at line 506 of file system.h.

typedef std::map<std::string, NumericVector<Number> *>::iterator libMesh::System::vectors_iterator
inherited

Vector iterator typedefs.

Definition at line 734 of file system.h.

Constructor & Destructor Documentation

libMesh::NonlinearImplicitSystem::NonlinearImplicitSystem ( EquationSystems es,
const std::string &  name,
const unsigned int  number 
)

Constructor. Optionally initializes required data structures.

Definition at line 35 of file nonlinear_implicit_system.C.

References libMesh::EquationSystems::parameters, libMesh::Real, and libMesh::Parameters::set().

37  :
38 
39  Parent (es, name_in, number_in),
41  diff_solver (),
44 {
45  // Set default parameters
46  // These were chosen to match the Petsc defaults
47  es.parameters.set<Real> ("linear solver tolerance") = 1e-5;
48  es.parameters.set<Real> ("linear solver minimum tolerance") = 1e-5;
49  es.parameters.set<unsigned int>("linear solver maximum iterations") = 10000;
50 
51  es.parameters.set<unsigned int>("nonlinear solver maximum iterations") = 50;
52  es.parameters.set<unsigned int>("nonlinear solver maximum function evaluations") = 10000;
53 
54  es.parameters.set<Real>("nonlinear solver absolute residual tolerance") = 1e-35;
55  es.parameters.set<Real>("nonlinear solver relative residual tolerance") = 1e-8;
56  es.parameters.set<Real>("nonlinear solver absolute step tolerance") = 1e-8;
57  es.parameters.set<Real>("nonlinear solver relative step tolerance") = 1e-8;
58 }
std::unique_ptr< NonlinearSolver< Number > > nonlinear_solver
std::unique_ptr< DiffSolver > diff_solver
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
static std::unique_ptr< NonlinearSolver< Number > > build(sys_type &s, const SolverPackage solver_package=libMesh::default_solver_package())
libMesh::NonlinearImplicitSystem::~NonlinearImplicitSystem ( )
virtual

Destructor.

Definition at line 62 of file nonlinear_implicit_system.C.

References clear().

63 {
64  // Clear data
65  this->clear();
66 }
virtual void clear() libmesh_override

Member Function Documentation

void libMesh::System::activate ( )
inlineinherited

Activates the system. Only active systems are solved.

Definition at line 2054 of file system.h.

References libMesh::System::_active.

Referenced by libMesh::System::get_equation_systems().

2055 {
2056  _active = true;
2057 }
bool libMesh::System::active ( ) const
inlineinherited
Returns
true if the system is active, false otherwise. An active system will be solved.

Definition at line 2046 of file system.h.

References libMesh::System::_active.

Referenced by libMesh::System::get_equation_systems().

2047 {
2048  return _active;
2049 }
NumericVector< Number > & libMesh::System::add_adjoint_rhs ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's adjoint rhs vectors, by default the one corresponding to the first qoi. Creates the vector if it doesn't already exist.

Definition at line 1022 of file system.C.

References libMesh::System::add_vector().

Referenced by libMesh::ExplicitSystem::assemble_qoi_derivative(), libMesh::FEMSystem::assemble_qoi_derivative(), and libMesh::System::project_solution_on_reinit().

1023 {
1024  std::ostringstream adjoint_rhs_name;
1025  adjoint_rhs_name << "adjoint_rhs" << i;
1026 
1027  return this->add_vector(adjoint_rhs_name.str(), false);
1028 }
NumericVector< Number > & add_vector(const std::string &vec_name, const bool projections=true, const ParallelType type=PARALLEL)
Definition: system.C:662
NumericVector< Number > & libMesh::System::add_adjoint_solution ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's adjoint solution vectors, by default the one corresponding to the first qoi. Creates the vector if it doesn't already exist.

Definition at line 958 of file system.C.

References libMesh::System::add_vector(), and libMesh::System::set_vector_as_adjoint().

Referenced by libMesh::ImplicitSystem::adjoint_solve(), and libMesh::System::project_solution_on_reinit().

959 {
960  std::ostringstream adjoint_name;
961  adjoint_name << "adjoint_solution" << i;
962 
963  NumericVector<Number> & returnval = this->add_vector(adjoint_name.str());
964  this->set_vector_as_adjoint(adjoint_name.str(), i);
965  return returnval;
966 }
void set_vector_as_adjoint(const std::string &vec_name, int qoi_num)
Definition: system.C:886
NumericVector< Number > & add_vector(const std::string &vec_name, const bool projections=true, const ParallelType type=PARALLEL)
Definition: system.C:662
SparseMatrix< Number > & libMesh::ImplicitSystem::add_matrix ( const std::string &  mat_name)
inherited

Adds the additional matrix mat_name to this system. Only allowed prior to assemble(). All additional matrices have the same sparsity pattern as the matrix used during solution. When not System but the user wants to initialize the mayor matrix, then all the additional matrices, if existent, have to be initialized by the user, too.

Definition at line 210 of file implicit_system.C.

References libMesh::ImplicitSystem::_can_add_matrices, libMesh::ImplicitSystem::_matrices, libMesh::SparseMatrix< T >::build(), libMesh::ParallelObject::comm(), and libMesh::ImplicitSystem::have_matrix().

Referenced by libMesh::ImplicitSystem::add_system_matrix(), libMesh::EigenTimeSolver::init(), and libMesh::NewmarkSystem::NewmarkSystem().

211 {
212  // only add matrices before initializing...
213  if (!_can_add_matrices)
214  libmesh_error_msg("ERROR: Too late. Cannot add matrices to the system after initialization"
215  << "\n any more. You should have done this earlier.");
216 
217  // Return the matrix if it is already there.
218  if (this->have_matrix(mat_name))
219  return *(_matrices[mat_name]);
220 
221  // Otherwise build the matrix and return it.
222  SparseMatrix<Number> * buf = SparseMatrix<Number>::build(this->comm()).release();
223  _matrices.insert (std::make_pair (mat_name, buf));
224 
225  return *buf;
226 }
static std::unique_ptr< SparseMatrix< T > > build(const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
std::map< std::string, SparseMatrix< Number > * > _matrices
bool have_matrix(const std::string &mat_name) const
const Parallel::Communicator & comm() const
NumericVector< Number > & libMesh::System::add_sensitivity_rhs ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's sensitivity rhs vectors, by default the one corresponding to the first parameter. Creates the vector if it doesn't already exist.

Definition at line 1052 of file system.C.

References libMesh::System::add_vector().

Referenced by libMesh::ImplicitSystem::assemble_residual_derivatives(), and libMesh::System::project_solution_on_reinit().

1053 {
1054  std::ostringstream sensitivity_rhs_name;
1055  sensitivity_rhs_name << "sensitivity_rhs" << i;
1056 
1057  return this->add_vector(sensitivity_rhs_name.str(), false);
1058 }
NumericVector< Number > & add_vector(const std::string &vec_name, const bool projections=true, const ParallelType type=PARALLEL)
Definition: system.C:662
NumericVector< Number > & libMesh::System::add_sensitivity_solution ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's solution sensitivity vectors, by default the one corresponding to the first parameter. Creates the vector if it doesn't already exist.

Definition at line 907 of file system.C.

References libMesh::System::add_vector().

Referenced by libMesh::System::project_solution_on_reinit(), and libMesh::ImplicitSystem::sensitivity_solve().

908 {
909  std::ostringstream sensitivity_name;
910  sensitivity_name << "sensitivity_solution" << i;
911 
912  return this->add_vector(sensitivity_name.str());
913 }
NumericVector< Number > & add_vector(const std::string &vec_name, const bool projections=true, const ParallelType type=PARALLEL)
Definition: system.C:662
unsigned int libMesh::System::add_variable ( const std::string &  var,
const FEType type,
const std::set< subdomain_id_type > *const  active_subdomains = libmesh_nullptr 
)
inherited

Adds the variable var to the list of variables for this system.

Returns
The index number for the new variable.

Definition at line 1082 of file system.C.

References libMesh::System::_variable_groups, libMesh::System::_variable_numbers, libMesh::System::_variables, libMesh::System::add_variables(), libMesh::VariableGroup::append(), libMesh::System::identify_variable_groups(), libMesh::System::is_initialized(), libmesh_nullptr, libMesh::System::n_variable_groups(), libMesh::System::n_vars(), libMesh::System::number(), libMesh::System::variable_name(), and libMesh::System::variable_type().

Referenced by libMesh::DifferentiableSystem::add_second_order_dot_vars(), libMesh::System::add_variable(), libMesh::ErrorVector::plot_error(), and libMesh::System::project_solution_on_reinit().

1085 {
1086  libmesh_assert(!this->is_initialized());
1087 
1088  // Make sure the variable isn't there already
1089  // or if it is, that it's the type we want
1090  for (unsigned int v=0; v<this->n_vars(); v++)
1091  if (this->variable_name(v) == var)
1092  {
1093  if (this->variable_type(v) == type)
1094  return _variables[v].number();
1095 
1096  libmesh_error_msg("ERROR: incompatible variable " << var << " has already been added for this system!");
1097  }
1098 
1099  // Optimize for VariableGroups here - if the user is adding multiple
1100  // variables of the same FEType and subdomain restriction, catch
1101  // that here and add them as members of the same VariableGroup.
1102  //
1103  // start by setting this flag to whatever the user has requested
1104  // and then consider the conditions which should negate it.
1105  bool should_be_in_vg = this->identify_variable_groups();
1106 
1107  // No variable groups, nothing to add to
1108  if (!this->n_variable_groups())
1109  should_be_in_vg = false;
1110 
1111  else
1112  {
1113  VariableGroup & vg(_variable_groups.back());
1114 
1115  // get a pointer to their subdomain restriction, if any.
1116  const std::set<subdomain_id_type> * const
1117  their_active_subdomains (vg.implicitly_active() ?
1118  libmesh_nullptr : &vg.active_subdomains());
1119 
1120  // Different types?
1121  if (vg.type() != type)
1122  should_be_in_vg = false;
1123 
1124  // they are restricted, we aren't?
1125  if (their_active_subdomains && !active_subdomains)
1126  should_be_in_vg = false;
1127 
1128  // they aren't restricted, we are?
1129  if (!their_active_subdomains && active_subdomains)
1130  should_be_in_vg = false;
1131 
1132  if (their_active_subdomains && active_subdomains)
1133  // restricted to different sets?
1134  if (*their_active_subdomains != *active_subdomains)
1135  should_be_in_vg = false;
1136 
1137  // OK, after all that, append the variable to the vg if none of the conditions
1138  // were violated
1139  if (should_be_in_vg)
1140  {
1141  const unsigned short curr_n_vars = cast_int<unsigned short>
1142  (this->n_vars());
1143 
1144  vg.append (var);
1145 
1146  _variables.push_back(vg(vg.n_variables()-1));
1147  _variable_numbers[var] = curr_n_vars;
1148  return curr_n_vars;
1149  }
1150  }
1151 
1152  // otherwise, fall back to adding a single variable group
1153  return this->add_variables (std::vector<std::string>(1, var),
1154  type,
1155  active_subdomains);
1156 }
std::map< std::string, unsigned short int > _variable_numbers
Definition: system.h:1903
const std::string & variable_name(const unsigned int i) const
Definition: system.h:2134
const class libmesh_nullptr_t libmesh_nullptr
std::vector< Variable > _variables
Definition: system.h:1892
const FEType & variable_type(const unsigned int i) const
Definition: system.h:2164
unsigned int n_variable_groups() const
Definition: system.h:2094
std::vector< VariableGroup > _variable_groups
Definition: system.h:1897
bool is_initialized()
Definition: system.h:2070
bool identify_variable_groups() const
Definition: system.h:2182
unsigned int number() const
Definition: system.h:2006
unsigned int add_variables(const std::vector< std::string > &vars, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=libmesh_nullptr)
Definition: system.C:1172
unsigned int n_vars() const
Definition: system.h:2086
unsigned int libMesh::System::add_variable ( const std::string &  var,
const Order  order = FIRST,
const FEFamily  family = LAGRANGE,
const std::set< subdomain_id_type > *const  active_subdomains = libmesh_nullptr 
)
inherited

Adds the variable var to the list of variables for this system. Same as before, but assumes LAGRANGE as default value for FEType.family.

Definition at line 1160 of file system.C.

References libMesh::System::add_variable().

1164 {
1165  return this->add_variable(var,
1166  FEType(order, family),
1167  active_subdomains);
1168 }
unsigned int add_variable(const std::string &var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=libmesh_nullptr)
Definition: system.C:1082
unsigned int libMesh::System::add_variables ( const std::vector< std::string > &  vars,
const FEType type,
const std::set< subdomain_id_type > *const  active_subdomains = libmesh_nullptr 
)
inherited

Adds the variable var to the list of variables for this system.

Returns
The index number for the new variable.

Definition at line 1172 of file system.C.

References libMesh::System::_variable_groups, libMesh::System::_variable_numbers, libMesh::System::_variables, libMesh::System::is_initialized(), libmesh_nullptr, libMesh::System::n_components(), libMesh::System::n_vars(), libMesh::System::number(), libMesh::System::variable_name(), and libMesh::System::variable_type().

Referenced by libMesh::System::add_variable(), libMesh::System::add_variables(), and libMesh::System::project_solution_on_reinit().

1175 {
1176  libmesh_assert(!this->is_initialized());
1177 
1178  // Make sure the variable isn't there already
1179  // or if it is, that it's the type we want
1180  for (std::size_t ov=0; ov<vars.size(); ov++)
1181  for (unsigned int v=0; v<this->n_vars(); v++)
1182  if (this->variable_name(v) == vars[ov])
1183  {
1184  if (this->variable_type(v) == type)
1185  return _variables[v].number();
1186 
1187  libmesh_error_msg("ERROR: incompatible variable " << vars[ov] << " has already been added for this system!");
1188  }
1189 
1190  const unsigned short curr_n_vars = cast_int<unsigned short>
1191  (this->n_vars());
1192 
1193  const unsigned int next_first_component = this->n_components();
1194 
1195  // Add the variable group to the list
1196  _variable_groups.push_back((active_subdomains == libmesh_nullptr) ?
1197  VariableGroup(this, vars, curr_n_vars,
1198  next_first_component, type) :
1199  VariableGroup(this, vars, curr_n_vars,
1200  next_first_component, type, *active_subdomains));
1201 
1202  const VariableGroup & vg (_variable_groups.back());
1203 
1204  // Add each component of the group individually
1205  for (std::size_t v=0; v<vars.size(); v++)
1206  {
1207  _variables.push_back (vg(v));
1208  _variable_numbers[vars[v]] = cast_int<unsigned short>
1209  (curr_n_vars+v);
1210  }
1211 
1212  libmesh_assert_equal_to ((curr_n_vars+vars.size()), this->n_vars());
1213 
1214  // BSK - Defer this now to System::init_data() so we can detect
1215  // VariableGroups 12/28/2012
1216  // // Add the variable group to the _dof_map
1217  // _dof_map->add_variable_group (vg);
1218 
1219  // Return the number of the new variable
1220  return cast_int<unsigned int>(curr_n_vars+vars.size()-1);
1221 }
std::map< std::string, unsigned short int > _variable_numbers
Definition: system.h:1903
const std::string & variable_name(const unsigned int i) const
Definition: system.h:2134
const class libmesh_nullptr_t libmesh_nullptr
std::vector< Variable > _variables
Definition: system.h:1892
const FEType & variable_type(const unsigned int i) const
Definition: system.h:2164
unsigned int n_components() const
Definition: system.h:2102
std::vector< VariableGroup > _variable_groups
Definition: system.h:1897
bool is_initialized()
Definition: system.h:2070
unsigned int number() const
Definition: system.h:2006
unsigned int n_vars() const
Definition: system.h:2086
unsigned int libMesh::System::add_variables ( const std::vector< std::string > &  vars,
const Order  order = FIRST,
const FEFamily  family = LAGRANGE,
const std::set< subdomain_id_type > *const  active_subdomains = libmesh_nullptr 
)
inherited

Adds the variable var to the list of variables for this system. Same as before, but assumes LAGRANGE as default value for FEType.family.

Definition at line 1225 of file system.C.

References libMesh::System::add_variables().

1229 {
1230  return this->add_variables(vars,
1231  FEType(order, family),
1232  active_subdomains);
1233 }
unsigned int add_variables(const std::vector< std::string > &vars, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=libmesh_nullptr)
Definition: system.C:1172
NumericVector< Number > & libMesh::System::add_vector ( const std::string &  vec_name,
const bool  projections = true,
const ParallelType  type = PARALLEL 
)
inherited

Adds the additional vector vec_name to this system. All the additional vectors are similarly distributed, like the solution, and initialized to zero.

By default vectors added by add_vector are projected to changed grids by reinit(). To zero them instead (more efficient), pass "false" as the second argument

Definition at line 662 of file system.C.

References libMesh::System::_dof_map, libMesh::System::_is_initialized, libMesh::System::_vector_is_adjoint, libMesh::System::_vector_projections, libMesh::System::_vector_types, libMesh::System::_vectors, libMesh::NumericVector< T >::build(), libMesh::ParallelObject::comm(), libMesh::GHOSTED, libMesh::System::have_vector(), libMesh::NumericVector< T >::init(), libMesh::System::n_dofs(), and libMesh::System::n_local_dofs().

Referenced by libMesh::System::add_adjoint_rhs(), libMesh::System::add_adjoint_solution(), libMesh::System::add_sensitivity_rhs(), libMesh::System::add_sensitivity_solution(), libMesh::ExplicitSystem::add_system_rhs(), libMesh::System::add_weighted_sensitivity_adjoint_solution(), libMesh::System::add_weighted_sensitivity_solution(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::SecondOrderUnsteadySolver::init(), libMesh::UnsteadySolver::init(), libMesh::OptimizationSystem::init_data(), libMesh::ContinuationSystem::init_data(), libMesh::NewmarkSystem::NewmarkSystem(), libMesh::FrequencySystem::set_frequencies(), libMesh::FrequencySystem::set_frequencies_by_range(), and libMesh::FrequencySystem::set_frequencies_by_steps().

665 {
666  // Return the vector if it is already there.
667  if (this->have_vector(vec_name))
668  return *(_vectors[vec_name]);
669 
670  // Otherwise build the vector
671  NumericVector<Number> * buf = NumericVector<Number>::build(this->comm()).release();
672  _vectors.insert (std::make_pair (vec_name, buf));
673  _vector_projections.insert (std::make_pair (vec_name, projections));
674 
675  _vector_types.insert (std::make_pair (vec_name, type));
676 
677  // Vectors are primal by default
678  _vector_is_adjoint.insert (std::make_pair (vec_name, -1));
679 
680  // Initialize it if necessary
681  if (_is_initialized)
682  {
683  if (type == GHOSTED)
684  {
685 #ifdef LIBMESH_ENABLE_GHOSTED
686  buf->init (this->n_dofs(), this->n_local_dofs(),
687  _dof_map->get_send_list(), false,
688  GHOSTED);
689 #else
690  libmesh_error_msg("Cannot initialize ghosted vectors when they are not enabled.");
691 #endif
692  }
693  else
694  buf->init (this->n_dofs(), this->n_local_dofs(), false, type);
695  }
696 
697  return *buf;
698 }
std::map< std::string, ParallelType > _vector_types
Definition: system.h:1933
bool _is_initialized
Definition: system.h:1952
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
bool have_vector(const std::string &vec_name) const
Definition: system.h:2206
std::map< std::string, int > _vector_is_adjoint
Definition: system.h:1928
static std::unique_ptr< NumericVector< T > > build(const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
dof_id_type n_local_dofs() const
Definition: system.C:185
std::map< std::string, NumericVector< Number > * > _vectors
Definition: system.h:1916
const Parallel::Communicator & comm() const
std::map< std::string, bool > _vector_projections
Definition: system.h:1922
dof_id_type n_dofs() const
Definition: system.C:148
NumericVector< Number > & libMesh::System::add_weighted_sensitivity_adjoint_solution ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's weighted sensitivity adjoint solution vectors, by default the one corresponding to the first qoi. Creates the vector if it doesn't already exist.

Definition at line 990 of file system.C.

References libMesh::System::add_vector(), and libMesh::System::set_vector_as_adjoint().

Referenced by libMesh::System::project_solution_on_reinit(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

991 {
992  std::ostringstream adjoint_name;
993  adjoint_name << "weighted_sensitivity_adjoint_solution" << i;
994 
995  NumericVector<Number> & returnval = this->add_vector(adjoint_name.str());
996  this->set_vector_as_adjoint(adjoint_name.str(), i);
997  return returnval;
998 }
void set_vector_as_adjoint(const std::string &vec_name, int qoi_num)
Definition: system.C:886
NumericVector< Number > & add_vector(const std::string &vec_name, const bool projections=true, const ParallelType type=PARALLEL)
Definition: system.C:662
NumericVector< Number > & libMesh::System::add_weighted_sensitivity_solution ( )
inherited
Returns
A reference to the solution of the last weighted sensitivity solve Creates the vector if it doesn't already exist.

Definition at line 937 of file system.C.

References libMesh::System::add_vector().

Referenced by libMesh::System::project_solution_on_reinit(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

938 {
939  return this->add_vector("weighted_sensitivity_solution");
940 }
NumericVector< Number > & add_vector(const std::string &vec_name, const bool projections=true, const ParallelType type=PARALLEL)
Definition: system.C:662
void libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity ( const QoISet qoi_indices,
const ParameterVector parameters,
SensitivityData sensitivities 
)
virtualinherited

Solves for the derivative of each of the system's quantities of interest q in qoi[qoi_indices] with respect to each parameter in parameters, placing the result for qoi i and parameter j into sensitivities[i][j].

Uses adjoint_solve() and the adjoint sensitivity method.

Currently uses finite differenced derivatives (partial q / partial p) and (partial R / partial p).

Reimplemented from libMesh::System.

Definition at line 704 of file implicit_system.C.

References std::abs(), libMesh::ImplicitSystem::adjoint_solve(), libMesh::SensitivityData::allocate_data(), libMesh::ExplicitSystem::assemble_qoi(), libMesh::ImplicitSystem::assemble_residual_derivatives(), libMesh::NumericVector< T >::dot(), libMesh::System::get_sensitivity_rhs(), libMesh::QoISet::has_index(), libMesh::System::is_adjoint_already_solved(), std::max(), libMesh::System::qoi, libMesh::Real, libMesh::ParameterVector::size(), and libMesh::TOLERANCE.

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

707 {
708  ParameterVector & parameters =
709  const_cast<ParameterVector &>(parameters_in);
710 
711  const unsigned int Np = cast_int<unsigned int>
712  (parameters.size());
713  const unsigned int Nq = cast_int<unsigned int>
714  (qoi.size());
715 
716  // An introduction to the problem:
717  //
718  // Residual R(u(p),p) = 0
719  // partial R / partial u = J = system matrix
720  //
721  // This implies that:
722  // d/dp(R) = 0
723  // (partial R / partial p) +
724  // (partial R / partial u) * (partial u / partial p) = 0
725 
726  // We first do an adjoint solve:
727  // J^T * z = (partial q / partial u)
728  // if we havent already or dont have an initial condition for the adjoint
729  if (!this->is_adjoint_already_solved())
730  {
731  this->adjoint_solve(qoi_indices);
732  }
733 
734  this->assemble_residual_derivatives(parameters_in);
735 
736  // Get ready to fill in sensitivities:
737  sensitivities.allocate_data(qoi_indices, *this, parameters);
738 
739  // We use the identities:
740  // dq/dp = (partial q / partial p) + (partial q / partial u) *
741  // (partial u / partial p)
742  // dq/dp = (partial q / partial p) + (J^T * z) *
743  // (partial u / partial p)
744  // dq/dp = (partial q / partial p) + z * J *
745  // (partial u / partial p)
746 
747  // Leading to our final formula:
748  // dq/dp = (partial q / partial p) - z * (partial R / partial p)
749 
750  // In the case of adjoints with heterogenous Dirichlet boundary
751  // function phi, where
752  // q := S(u) - R(u,phi)
753  // the final formula works out to:
754  // dq/dp = (partial S / partial p) - z * (partial R / partial p)
755  // Because we currently have no direct access to
756  // (partial S / partial p), we use the identity
757  // (partial S / partial p) = (partial q / partial p) +
758  // phi * (partial R / partial p)
759  // to derive an equivalent equation:
760  // dq/dp = (partial q / partial p) - (z-phi) * (partial R / partial p)
761 
762  // Since z-phi degrees of freedom are zero for constrained indices,
763  // we can use the same constrained -(partial R / partial p) that we
764  // use for forward sensitivity solves, taking into account the
765  // differing sign convention.
766  //
767  // Since that vector is constrained, its constrained indices are
768  // zero, so its product with phi is zero, so we can neglect the
769  // evaluation of phi terms.
770 
771  for (unsigned int j=0; j != Np; ++j)
772  {
773  // We currently get partial derivatives via central differencing
774 
775  // (partial q / partial p) ~= (q(p+dp)-q(p-dp))/(2*dp)
776  // (partial R / partial p) ~= (rhs(p+dp) - rhs(p-dp))/(2*dp)
777 
778  Number old_parameter = *parameters[j];
779 
780  const Real delta_p =
781  TOLERANCE * std::max(std::abs(old_parameter), 1e-3);
782 
783  *parameters[j] = old_parameter - delta_p;
784  this->assemble_qoi(qoi_indices);
785  std::vector<Number> qoi_minus = this->qoi;
786 
787  NumericVector<Number> & neg_partialR_partialp = this->get_sensitivity_rhs(j);
788 
789  *parameters[j] = old_parameter + delta_p;
790  this->assemble_qoi(qoi_indices);
791  std::vector<Number> & qoi_plus = this->qoi;
792 
793  std::vector<Number> partialq_partialp(Nq, 0);
794  for (unsigned int i=0; i != Nq; ++i)
795  if (qoi_indices.has_index(i))
796  partialq_partialp[i] = (qoi_plus[i] - qoi_minus[i]) / (2.*delta_p);
797 
798  // Don't leave the parameter changed
799  *parameters[j] = old_parameter;
800 
801  for (unsigned int i=0; i != Nq; ++i)
802  if (qoi_indices.has_index(i))
803  sensitivities[i][j] = partialq_partialp[i] +
804  neg_partialR_partialp.dot(this->get_adjoint_solution(i));
805  }
806 
807  // All parameters have been reset.
808  // Reset the original qoi.
809 
810  this->assemble_qoi(qoi_indices);
811 }
double abs(double a)
virtual std::pair< unsigned int, Real > adjoint_solve(const QoISet &qoi_indices=QoISet()) libmesh_override
NumericVector< Number > & get_sensitivity_rhs(unsigned int i=0)
Definition: system.C:1062
static const Real TOLERANCE
long double max(long double a, double b)
std::vector< Number > qoi
Definition: system.h:1539
bool is_adjoint_already_solved() const
Definition: system.h:374
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual void assemble_qoi(const QoISet &qoi_indices=QoISet()) libmesh_override
virtual void assemble_residual_derivatives(const ParameterVector &parameters) libmesh_override
std::pair< unsigned int, Real > libMesh::ImplicitSystem::adjoint_solve ( const QoISet qoi_indices = QoISet())
virtualinherited

Assembles & solves the linear system (dR/du)^T*z = dq/du, for those quantities of interest q specified by qoi_indices.

Leave qoi_indices empty to solve all adjoint problems.

Returns
A pair with the total number of linear iterations performed and the (sum of the) final residual norms

Reimplemented from libMesh::System.

Reimplemented in libMesh::DifferentiableSystem.

Definition at line 379 of file implicit_system.C.

References libMesh::System::add_adjoint_solution(), libMesh::LinearSolver< T >::adjoint_solve(), libMesh::System::assemble_before_solve, libMesh::ExplicitSystem::assemble_qoi_derivative(), libMesh::ImplicitSystem::assembly(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::System::get_adjoint_rhs(), libMesh::System::get_adjoint_solution(), libMesh::System::get_dof_map(), libMesh::ImplicitSystem::get_linear_solve_parameters(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::QoISet::has_index(), libMesh::ImplicitSystem::matrix, libMesh::System::qoi, and libMesh::ImplicitSystem::release_linear_solver().

Referenced by libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::DifferentiableSystem::adjoint_solve(), libMesh::ImplicitSystem::assembly(), libMesh::ImplicitSystem::qoi_parameter_hessian(), and libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product().

380 {
381  // Log how long the linear solve takes.
382  LOG_SCOPE("adjoint_solve()", "ImplicitSystem");
383 
384  if (this->assemble_before_solve)
385  // Assemble the linear system
386  this->assembly (/* get_residual = */ false,
387  /* get_jacobian = */ true);
388 
389  // The adjoint problem is linear
390  LinearSolver<Number> * linear_solver = this->get_linear_solver();
391 
392  // Reset and build the RHS from the QOI derivative
393  this->assemble_qoi_derivative(qoi_indices,
394  /* include_liftfunc = */ false,
395  /* apply_constraints = */ true);
396 
397  // Our iteration counts and residuals will be sums of the individual
398  // results
399  std::pair<unsigned int, Real> solver_params =
401  std::pair<unsigned int, Real> totalrval = std::make_pair(0,0.0);
402 
403  for (std::size_t i=0; i != this->qoi.size(); ++i)
404  if (qoi_indices.has_index(i))
405  {
406  const std::pair<unsigned int, Real> rval =
407  linear_solver->adjoint_solve (*matrix, this->add_adjoint_solution(i),
408  this->get_adjoint_rhs(i),
409  solver_params.second,
410  solver_params.first);
411 
412  totalrval.first += rval.first;
413  totalrval.second += rval.second;
414  }
415 
416  this->release_linear_solver(linear_solver);
417 
418  // The linear solver may not have fit our constraints exactly
419 #ifdef LIBMESH_ENABLE_CONSTRAINTS
420  for (std::size_t i=0; i != this->qoi.size(); ++i)
421  if (qoi_indices.has_index(i))
423  (this->get_adjoint_solution(i), i);
424 #endif
425 
426  return totalrval;
427 }
virtual LinearSolver< Number > * get_linear_solver() const
NumericVector< Number > & add_adjoint_solution(unsigned int i=0)
Definition: system.C:958
virtual std::pair< unsigned int, Real > get_linear_solve_parameters() const
virtual void assemble_qoi_derivative(const QoISet &qoi_indices=QoISet(), bool include_liftfunc=true, bool apply_constraints=true) libmesh_override
virtual void assembly(bool, bool, bool=false, bool=false)
const DofMap & get_dof_map() const
Definition: system.h:2030
std::vector< Number > qoi
Definition: system.h:1539
SparseMatrix< Number > * matrix
virtual void release_linear_solver(LinearSolver< Number > *) const
NumericVector< Number > & get_adjoint_solution(unsigned int i=0)
Definition: system.C:970
bool assemble_before_solve
Definition: system.h:1463
void enforce_adjoint_constraints_exactly(NumericVector< Number > &v, unsigned int q) const
NumericVector< Number > & get_adjoint_rhs(unsigned int i=0)
Definition: system.C:1032
void libMesh::ImplicitSystem::assemble ( )
virtualinherited

Prepares matrix and rhs for system assembly, then calls user assembly function. Can be overridden in derived classes.

Reimplemented from libMesh::System.

Reimplemented in libMesh::DifferentiableSystem, libMesh::LinearImplicitSystem, libMesh::FrequencySystem, and libMesh::NewmarkSystem.

Definition at line 191 of file implicit_system.C.

References libMesh::System::assemble(), libMesh::SparseMatrix< T >::initialized(), libMesh::NumericVector< T >::initialized(), libMesh::ImplicitSystem::matrix, libMesh::ExplicitSystem::rhs, libMesh::SparseMatrix< T >::zero(), libMesh::NumericVector< T >::zero(), and libMesh::ImplicitSystem::zero_out_matrix_and_rhs.

Referenced by libMesh::LinearImplicitSystem::assemble().

192 {
193  libmesh_assert(matrix);
194  libmesh_assert (matrix->initialized());
195  libmesh_assert(rhs);
196  libmesh_assert (rhs->initialized());
197 
199  {
200  matrix->zero ();
201  rhs->zero ();
202  }
203 
204  // Call the base class assemble function
205  Parent::assemble ();
206 }
virtual void assemble()
Definition: system.C:460
NumericVector< Number > * rhs
virtual bool initialized() const
virtual void zero()=0
virtual bool initialized() const
virtual void zero()=0
SparseMatrix< Number > * matrix
void libMesh::ExplicitSystem::assemble_qoi ( const QoISet qoi_indices = QoISet())
virtualinherited

Prepares qoi for quantity of interest assembly, then calls user qoi function. Can be overridden in derived classes.

Reimplemented from libMesh::System.

Reimplemented in libMesh::FEMSystem.

Definition at line 56 of file explicit_system.C.

References libMesh::System::assemble_qoi(), libMesh::QoISet::has_index(), and libMesh::System::qoi.

Referenced by libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), and libMesh::ExplicitSystem::system().

57 {
58  // The user quantity of interest assembly gets to expect to
59  // accumulate on initially zero values
60  for (std::size_t i=0; i != qoi.size(); ++i)
61  if (qoi_indices.has_index(i))
62  qoi[i] = 0;
63 
64  Parent::assemble_qoi (qoi_indices);
65 }
std::vector< Number > qoi
Definition: system.h:1539
virtual void assemble_qoi(const QoISet &qoi_indices=QoISet())
Definition: system.C:471
void libMesh::ExplicitSystem::assemble_qoi_derivative ( const QoISet qoi_indices = QoISet(),
bool  include_liftfunc = true,
bool  apply_constraints = true 
)
virtualinherited

Prepares adjoint_rhs for quantity of interest derivative assembly, then calls user qoi derivative function. Can be overridden in derived classes.

Reimplemented from libMesh::System.

Reimplemented in libMesh::FEMSystem.

Definition at line 69 of file explicit_system.C.

References libMesh::System::add_adjoint_rhs(), libMesh::System::assemble_qoi_derivative(), libMesh::QoISet::has_index(), libMesh::System::qoi, and libMesh::NumericVector< T >::zero().

Referenced by libMesh::ImplicitSystem::adjoint_solve(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::ExplicitSystem::system(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

72 {
73  // The user quantity of interest derivative assembly gets to expect
74  // to accumulate on initially zero vectors
75  for (std::size_t i=0; i != qoi.size(); ++i)
76  if (qoi_indices.has_index(i))
77  this->add_adjoint_rhs(i).zero();
78 
79  Parent::assemble_qoi_derivative (qoi_indices, include_liftfunc,
80  apply_constraints);
81 }
virtual void assemble_qoi_derivative(const QoISet &qoi_indices=QoISet(), bool include_liftfunc=true, bool apply_constraints=true)
Definition: system.C:482
virtual void zero()=0
std::vector< Number > qoi
Definition: system.h:1539
NumericVector< Number > & add_adjoint_rhs(unsigned int i=0)
Definition: system.C:1022
void libMesh::ImplicitSystem::assemble_residual_derivatives ( const ParameterVector parameters)
virtualinherited

Residual parameter derivative function.

Uses finite differences by default.

This will assemble the sensitivity rhs vectors to hold -(partial R / partial p_i), making them ready to solve the forward sensitivity equation.

Can be overridden in derived classes.

Reimplemented from libMesh::System.

Definition at line 661 of file implicit_system.C.

References std::abs(), libMesh::System::add_sensitivity_rhs(), libMesh::ImplicitSystem::assembly(), libMesh::NumericVector< T >::close(), std::max(), libMesh::Real, libMesh::ExplicitSystem::rhs, libMesh::ParameterVector::size(), and libMesh::TOLERANCE.

Referenced by libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::ImplicitSystem::assembly(), and libMesh::ImplicitSystem::sensitivity_solve().

662 {
663  ParameterVector & parameters =
664  const_cast<ParameterVector &>(parameters_in);
665 
666  const unsigned int Np = cast_int<unsigned int>
667  (parameters.size());
668 
669  for (unsigned int p=0; p != Np; ++p)
670  {
671  NumericVector<Number> & sensitivity_rhs = this->add_sensitivity_rhs(p);
672 
673  // Approximate -(partial R / partial p) by
674  // (R(p-dp) - R(p+dp)) / (2*dp)
675 
676  Number old_parameter = *parameters[p];
677 
678  const Real delta_p =
679  TOLERANCE * std::max(std::abs(old_parameter), 1e-3);
680 
681  *parameters[p] -= delta_p;
682 
683  // this->assembly(true, false, true);
684  this->assembly(true, false, false);
685  this->rhs->close();
686  sensitivity_rhs = *this->rhs;
687 
688  *parameters[p] = old_parameter + delta_p;
689 
690  // this->assembly(true, false, true);
691  this->assembly(true, false, false);
692  this->rhs->close();
693 
694  sensitivity_rhs -= *this->rhs;
695  sensitivity_rhs /= (2*delta_p);
696  sensitivity_rhs.close();
697 
698  *parameters[p] = old_parameter;
699  }
700 }
double abs(double a)
NumericVector< Number > * rhs
NumericVector< Number > & add_sensitivity_rhs(unsigned int i=0)
Definition: system.C:1052
static const Real TOLERANCE
long double max(long double a, double b)
virtual void assembly(bool, bool, bool=false, bool=false)
virtual void close()=0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void libMesh::NonlinearImplicitSystem::assembly ( bool  get_residual,
bool  get_jacobian,
bool  apply_heterogeneous_constraints = false,
bool  apply_no_constraints = false 
)
virtual

Assembles a residual in rhs and/or a jacobian in matrix, as requested.

Reimplemented from libMesh::ImplicitSystem.

Definition at line 211 of file nonlinear_implicit_system.C.

References libMesh::System::current_local_solution, libmesh_nullptr, libMesh::ImplicitSystem::matrix, nonlinear_solver, libMesh::ExplicitSystem::rhs, and libMesh::System::update().

Referenced by system().

215 {
216  // Get current_local_solution in sync
217  this->update();
218 
219  //-----------------------------------------------------------------------------
220  // if the user has provided both function pointers and objects only the pointer
221  // will be used, so catch that as an error
222  if (nonlinear_solver->jacobian && nonlinear_solver->jacobian_object)
223  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the Jacobian!");
224 
225  if (nonlinear_solver->residual && nonlinear_solver->residual_object)
226  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the Residual!");
227 
228  if (nonlinear_solver->matvec && nonlinear_solver->residual_and_jacobian_object)
229  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
230 
231 
232  if (get_jacobian)
233  {
234  if (nonlinear_solver->jacobian != libmesh_nullptr)
235  nonlinear_solver->jacobian (*current_local_solution.get(), *matrix, *this);
236 
237  else if (nonlinear_solver->jacobian_object != libmesh_nullptr)
238  nonlinear_solver->jacobian_object->jacobian (*current_local_solution.get(), *matrix, *this);
239 
240  else if (nonlinear_solver->matvec != libmesh_nullptr)
241  nonlinear_solver->matvec (*current_local_solution.get(), get_residual ? rhs : libmesh_nullptr, matrix, *this);
242 
243  else if (nonlinear_solver->residual_and_jacobian_object != libmesh_nullptr)
244  nonlinear_solver->residual_and_jacobian_object->residual_and_jacobian (*current_local_solution.get(), get_residual ? rhs : libmesh_nullptr, matrix, *this);
245 
246  else
247  libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
248  }
249 
250  if (get_residual)
251  {
252  if (nonlinear_solver->residual != libmesh_nullptr)
253  nonlinear_solver->residual (*current_local_solution.get(), *rhs, *this);
254 
255  else if (nonlinear_solver->residual_object != libmesh_nullptr)
256  nonlinear_solver->residual_object->residual (*current_local_solution.get(), *rhs, *this);
257 
258  else if (nonlinear_solver->matvec != libmesh_nullptr)
259  {
260  // we might have already grabbed the residual and jacobian together
261  if (!get_jacobian)
263  }
264 
265  else if (nonlinear_solver->residual_and_jacobian_object != libmesh_nullptr)
266  {
267  // we might have already grabbed the residual and jacobian together
268  if (!get_jacobian)
269  nonlinear_solver->residual_and_jacobian_object->residual_and_jacobian (*current_local_solution.get(), rhs, libmesh_nullptr, *this);
270  }
271 
272  else
273  libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
274  }
275  else
276  libmesh_assert(get_jacobian); // I can't believe you really wanted to assemble *nothing*
277 }
std::unique_ptr< NonlinearSolver< Number > > nonlinear_solver
const class libmesh_nullptr_t libmesh_nullptr
NumericVector< Number > * rhs
virtual void update()
Definition: system.C:406
SparseMatrix< Number > * matrix
std::unique_ptr< NumericVector< Number > > current_local_solution
Definition: system.h:1521
void libMesh::System::attach_assemble_function ( void   fptrEquationSystems &es, const std::string &name)
inherited

Register a user function to use in assembling the system matrix and RHS.

Definition at line 1764 of file system.C.

References libMesh::System::_assemble_system_function, libMesh::System::_assemble_system_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1766 {
1767  libmesh_assert(fptr);
1768 
1770  {
1771  libmesh_here();
1772  libMesh::out << "WARNING: Cannot specify both assembly function and object!"
1773  << std::endl;
1774 
1776  }
1777 
1779 }
Assembly * _assemble_system_object
Definition: system.h:1822
const class libmesh_nullptr_t libmesh_nullptr
void(* _assemble_system_function)(EquationSystems &es, const std::string &name)
Definition: system.h:1816
OStreamProxy out(std::cout)
void libMesh::System::attach_assemble_object ( System::Assembly assemble_in)
inherited

Register a user object to use in assembling the system matrix and RHS.

Definition at line 1783 of file system.C.

References libMesh::System::_assemble_system_function, libMesh::System::_assemble_system_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1784 {
1786  {
1787  libmesh_here();
1788  libMesh::out << "WARNING: Cannot specify both assembly object and function!"
1789  << std::endl;
1790 
1792  }
1793 
1794  _assemble_system_object = &assemble_in;
1795 }
Assembly * _assemble_system_object
Definition: system.h:1822
const class libmesh_nullptr_t libmesh_nullptr
void(* _assemble_system_function)(EquationSystems &es, const std::string &name)
Definition: system.h:1816
OStreamProxy out(std::cout)
void libMesh::System::attach_constraint_function ( void   fptrEquationSystems &es, const std::string &name)
inherited

Register a user function for imposing constraints.

Definition at line 1799 of file system.C.

References libMesh::System::_constrain_system_function, libMesh::System::_constrain_system_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1801 {
1802  libmesh_assert(fptr);
1803 
1805  {
1806  libmesh_here();
1807  libMesh::out << "WARNING: Cannot specify both constraint function and object!"
1808  << std::endl;
1809 
1811  }
1812 
1814 }
void(* _constrain_system_function)(EquationSystems &es, const std::string &name)
Definition: system.h:1827
Constraint * _constrain_system_object
Definition: system.h:1833
const class libmesh_nullptr_t libmesh_nullptr
OStreamProxy out(std::cout)
void libMesh::System::attach_constraint_object ( System::Constraint constrain)
inherited

Register a user object for imposing constraints.

Definition at line 1818 of file system.C.

References libMesh::System::_constrain_system_function, libMesh::System::_constrain_system_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1819 {
1821  {
1822  libmesh_here();
1823  libMesh::out << "WARNING: Cannot specify both constraint object and function!"
1824  << std::endl;
1825 
1827  }
1828 
1829  _constrain_system_object = &constrain;
1830 }
void(* _constrain_system_function)(EquationSystems &es, const std::string &name)
Definition: system.h:1827
Constraint * _constrain_system_object
Definition: system.h:1833
const class libmesh_nullptr_t libmesh_nullptr
OStreamProxy out(std::cout)
void libMesh::System::attach_init_function ( void   fptrEquationSystems &es, const std::string &name)
inherited

Register a user function to use in initializing the system.

Definition at line 1729 of file system.C.

References libMesh::System::_init_system_function, libMesh::System::_init_system_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1731 {
1732  libmesh_assert(fptr);
1733 
1735  {
1736  libmesh_here();
1737  libMesh::out << "WARNING: Cannot specify both initialization function and object!"
1738  << std::endl;
1739 
1741  }
1742 
1743  _init_system_function = fptr;
1744 }
const class libmesh_nullptr_t libmesh_nullptr
Initialization * _init_system_object
Definition: system.h:1811
void(* _init_system_function)(EquationSystems &es, const std::string &name)
Definition: system.h:1805
OStreamProxy out(std::cout)
void libMesh::System::attach_init_object ( System::Initialization init_in)
inherited

Register a user class to use to initialize the system.

Note
This is exclusive with the attach_init_function.

Definition at line 1748 of file system.C.

References libMesh::System::_init_system_function, libMesh::System::_init_system_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1749 {
1751  {
1752  libmesh_here();
1753  libMesh::out << "WARNING: Cannot specify both initialization object and function!"
1754  << std::endl;
1755 
1757  }
1758 
1759  _init_system_object = &init_in;
1760 }
const class libmesh_nullptr_t libmesh_nullptr
Initialization * _init_system_object
Definition: system.h:1811
void(* _init_system_function)(EquationSystems &es, const std::string &name)
Definition: system.h:1805
OStreamProxy out(std::cout)
void libMesh::System::attach_QOI_derivative ( void   fptrEquationSystems &es, const std::string &name, const QoISet &qoi_indices, bool include_liftfunc, bool apply_constraints)
inherited

Register a user function for evaluating derivatives of a quantity of interest with respect to test functions, whose values should be placed in System::rhs

Definition at line 1870 of file system.C.

References libMesh::System::_qoi_evaluate_derivative_function, libMesh::System::_qoi_evaluate_derivative_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1872 {
1873  libmesh_assert(fptr);
1874 
1876  {
1877  libmesh_here();
1878  libMesh::out << "WARNING: Cannot specify both QOI derivative function and object!"
1879  << std::endl;
1880 
1882  }
1883 
1885 }
const class libmesh_nullptr_t libmesh_nullptr
QOIDerivative * _qoi_evaluate_derivative_object
Definition: system.h:1859
OStreamProxy out(std::cout)
void(* _qoi_evaluate_derivative_function)(EquationSystems &es, const std::string &name, const QoISet &qoi_indices, bool include_liftfunc, bool apply_constraints)
Definition: system.h:1850
void libMesh::System::attach_QOI_derivative_object ( QOIDerivative qoi_derivative)
inherited

Register a user object for evaluating derivatives of a quantity of interest with respect to test functions, whose values should be placed in System::rhs

Definition at line 1889 of file system.C.

References libMesh::System::_qoi_evaluate_derivative_function, libMesh::System::_qoi_evaluate_derivative_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1890 {
1892  {
1893  libmesh_here();
1894  libMesh::out << "WARNING: Cannot specify both QOI derivative object and function!"
1895  << std::endl;
1896 
1898  }
1899 
1900  _qoi_evaluate_derivative_object = &qoi_derivative;
1901 }
const class libmesh_nullptr_t libmesh_nullptr
QOIDerivative * _qoi_evaluate_derivative_object
Definition: system.h:1859
OStreamProxy out(std::cout)
void(* _qoi_evaluate_derivative_function)(EquationSystems &es, const std::string &name, const QoISet &qoi_indices, bool include_liftfunc, bool apply_constraints)
Definition: system.h:1850
void libMesh::System::attach_QOI_function ( void   fptrEquationSystems &es, const std::string &name, const QoISet &qoi_indices)
inherited

Register a user function for evaluating the quantities of interest, whose values should be placed in System::qoi

Definition at line 1834 of file system.C.

References libMesh::System::_qoi_evaluate_function, libMesh::System::_qoi_evaluate_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1837 {
1838  libmesh_assert(fptr);
1839 
1841  {
1842  libmesh_here();
1843  libMesh::out << "WARNING: Cannot specify both QOI function and object!"
1844  << std::endl;
1845 
1847  }
1848 
1849  _qoi_evaluate_function = fptr;
1850 }
const class libmesh_nullptr_t libmesh_nullptr
void(* _qoi_evaluate_function)(EquationSystems &es, const std::string &name, const QoISet &qoi_indices)
Definition: system.h:1838
QOI * _qoi_evaluate_object
Definition: system.h:1845
OStreamProxy out(std::cout)
void libMesh::System::attach_QOI_object ( QOI qoi)
inherited

Register a user object for evaluating the quantities of interest, whose values should be placed in System::qoi

Definition at line 1854 of file system.C.

References libMesh::System::_qoi_evaluate_function, libMesh::System::_qoi_evaluate_object, libmesh_nullptr, and libMesh::out.

Referenced by libMesh::System::read_parallel_data().

1855 {
1857  {
1858  libmesh_here();
1859  libMesh::out << "WARNING: Cannot specify both QOI object and function!"
1860  << std::endl;
1861 
1863  }
1864 
1865  _qoi_evaluate_object = &qoi_in;
1866 }
const class libmesh_nullptr_t libmesh_nullptr
void(* _qoi_evaluate_function)(EquationSystems &es, const std::string &name, const QoISet &qoi_indices)
Definition: system.h:1838
QOI * _qoi_evaluate_object
Definition: system.h:1845
OStreamProxy out(std::cout)
void libMesh::System::boundary_project_solution ( const std::set< boundary_id_type > &  b,
const std::vector< unsigned int > &  variables,
FunctionBase< Number > *  f,
FunctionBase< Gradient > *  g = libmesh_nullptr 
)
inherited

Projects arbitrary boundary functions onto a vector of degree of freedom values for the current system. Only degrees of freedom which affect the function's trace on a boundary in the set b are affected. Only degrees of freedom associated with the variables listed in the vector variables are projected. The function value f and its gradient g are user-provided cloneable functors. A gradient g is only required/used for projecting onto finite element spaces with continuous derivatives. If non-default Parameters are to be used, they can be provided in the parameters argument.

This method projects an arbitrary boundary function onto the solution via L2 projections and nodal interpolations on each element.

Definition at line 986 of file system_projection.C.

990 {
991  this->boundary_project_vector(b, variables, *solution, f, g);
992 
993  solution->localize(*current_local_solution);
994 }
void boundary_project_vector(const std::set< boundary_id_type > &b, const std::vector< unsigned int > &variables, NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
std::unique_ptr< NumericVector< Number > > solution
Definition: system.h:1509
std::unique_ptr< NumericVector< Number > > current_local_solution
Definition: system.h:1521
void libMesh::System::boundary_project_solution ( const std::set< boundary_id_type > &  b,
const std::vector< unsigned int > &  variables,
ValueFunctionPointer  fptr,
GradientFunctionPointer  gptr,
const Parameters parameters 
)
inherited

Projects arbitrary boundary functions onto a vector of degree of freedom values for the current system. Only degrees of freedom which affect the function's trace on a boundary in the set b are affected. Only degrees of freedom associated with the variables listed in the vector variables are projected. The function value fptr and its gradient gptr are represented by function pointers. A gradient gptr is only required/used for projecting onto finite element spaces with continuous derivatives.

This method projects components of an arbitrary boundary function onto the solution via L2 projections and nodal interpolations on each element.

Definition at line 969 of file system_projection.C.

974 {
975  WrappedFunction<Number> f(*this, fptr, &parameters);
976  WrappedFunction<Gradient> g(*this, gptr, &parameters);
977  this->boundary_project_solution(b, variables, &f, &g);
978 }
void boundary_project_solution(const std::set< boundary_id_type > &b, const std::vector< unsigned int > &variables, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr)
void libMesh::System::boundary_project_vector ( const std::set< boundary_id_type > &  b,
const std::vector< unsigned int > &  variables,
NumericVector< Number > &  new_vector,
FunctionBase< Number > *  f,
FunctionBase< Gradient > *  g = libmesh_nullptr,
int  is_adjoint = -1 
) const
inherited

Projects arbitrary boundary functions onto a vector of degree of freedom values for the current system. Only degrees of freedom which affect the function's trace on a boundary in the set b are affected. Only degrees of freedom associated with the variables listed in the vector variables are projected. The function value f and its gradient g are user-provided cloneable functors. A gradient g is only required/used for projecting onto finite element spaces with continuous derivatives. If non-default Parameters are to be used, they can be provided in the parameters argument.

Constrain the new vector using the requested adjoint rather than primal constraints if is_adjoint is non-negative.

This method projects an arbitrary function via L2 projections and nodal interpolations on each element.

Definition at line 1022 of file system_projection.C.

References libMesh::NumericVector< T >::close(), and libMesh::Threads::parallel_for().

1028 {
1029  LOG_SCOPE ("boundary_project_vector()", "System");
1030 
1032  (ConstElemRange (this->get_mesh().active_local_elements_begin(),
1033  this->get_mesh().active_local_elements_end() ),
1034  BoundaryProjectSolution(b, variables, *this, f, g,
1035  this->get_equation_systems().parameters,
1036  new_vector)
1037  );
1038 
1039  // We don't do SCALAR dofs when just projecting the boundary, so
1040  // we're done here.
1041 
1042  new_vector.close();
1043 
1044 #ifdef LIBMESH_ENABLE_CONSTRAINTS
1045  if (is_adjoint == -1)
1046  this->get_dof_map().enforce_constraints_exactly(*this, &new_vector);
1047  else if (is_adjoint >= 0)
1049  is_adjoint);
1050 #endif
1051 }
void parallel_for(const Range &range, const Body &body)
Definition: threads_none.h:73
StoredRange< MeshBase::const_element_iterator, const Elem * > ConstElemRange
Definition: elem_range.h:34
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
void enforce_constraints_exactly(const System &system, NumericVector< Number > *v=libmesh_nullptr, bool homogeneous=false) const
virtual void close()=0
const EquationSystems & get_equation_systems() const
Definition: system.h:698
void enforce_adjoint_constraints_exactly(NumericVector< Number > &v, unsigned int q) const
void libMesh::System::boundary_project_vector ( const std::set< boundary_id_type > &  b,
const std::vector< unsigned int > &  variables,
ValueFunctionPointer  fptr,
GradientFunctionPointer  gptr,
const Parameters parameters,
NumericVector< Number > &  new_vector,
int  is_adjoint = -1 
) const
inherited

Projects arbitrary boundary functions onto a vector of degree of freedom values for the current system. Only degrees of freedom which affect the function's trace on a boundary in the set b are affected. Only degrees of freedom associated with the variables listed in the vector variables are projected. The function value fptr and its gradient gptr are represented by function pointers. A gradient gptr is only required/used for projecting onto finite element spaces with continuous derivatives.

Constrain the new vector using the requested adjoint rather than primal constraints if is_adjoint is non-negative.

This method projects an arbitrary boundary function via L2 projections and nodal interpolations on each element.

Definition at line 1004 of file system_projection.C.

1011 {
1012  WrappedFunction<Number> f(*this, fptr, &parameters);
1013  WrappedFunction<Gradient> g(*this, gptr, &parameters);
1014  this->boundary_project_vector(b, variables, new_vector, &f, &g,
1015  is_adjoint);
1016 }
void boundary_project_vector(const std::set< boundary_id_type > &b, const std::vector< unsigned int > &variables, NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
Real libMesh::System::calculate_norm ( const NumericVector< Number > &  v,
unsigned int  var,
FEMNormType  norm_type,
std::set< unsigned int > *  skip_dimensions = libmesh_nullptr 
) const
inherited
Returns
A norm of variable var in the vector v, in the specified norm (e.g. L2, L_INF, H1)

Definition at line 1364 of file system.C.

References libMesh::DISCRETE_L1, libMesh::DISCRETE_L2, libMesh::DISCRETE_L_INF, libMesh::System::discrete_var_norm(), libMesh::L2, libMesh::System::n_vars(), and libMesh::Real.

Referenced by libMesh::AdaptiveTimeSolver::calculate_norm(), libMesh::UnsteadySolver::du(), and libMesh::System::project_solution_on_reinit().

1368 {
1369  //short circuit to save time
1370  if (norm_type == DISCRETE_L1 ||
1371  norm_type == DISCRETE_L2 ||
1372  norm_type == DISCRETE_L_INF)
1373  return discrete_var_norm(v,var,norm_type);
1374 
1375  // Not a discrete norm
1376  std::vector<FEMNormType> norms(this->n_vars(), L2);
1377  std::vector<Real> weights(this->n_vars(), 0.0);
1378  norms[var] = norm_type;
1379  weights[var] = 1.0;
1380  Real val = this->calculate_norm(v, SystemNorm(norms, weights), skip_dimensions);
1381  return val;
1382 }
Real calculate_norm(const NumericVector< Number > &v, unsigned int var, FEMNormType norm_type, std::set< unsigned int > *skip_dimensions=libmesh_nullptr) const
Definition: system.C:1364
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
unsigned int n_vars() const
Definition: system.h:2086
Real discrete_var_norm(const NumericVector< Number > &v, unsigned int var, FEMNormType norm_type) const
Definition: system.C:1345
Real libMesh::System::calculate_norm ( const NumericVector< Number > &  v,
const SystemNorm norm,
std::set< unsigned int > *  skip_dimensions = libmesh_nullptr 
) const
inherited
Returns
A norm of the vector v, using component_norm and component_scale to choose and weight the norms of each variable.

Definition at line 1386 of file system.C.

References libMesh::System::_dof_map, libMesh::System::_mesh, std::abs(), libMesh::TypeVector< T >::add_scaled(), libMesh::TypeTensor< T >::add_scaled(), libMesh::FEGenericBase< OutputType >::build(), libMesh::NumericVector< T >::build(), libMesh::ParallelObject::comm(), libMesh::FEType::default_quadrature_rule(), libMesh::DISCRETE_L1, libMesh::DISCRETE_L2, libMesh::DISCRETE_L_INF, libMesh::System::discrete_var_norm(), libMesh::DofMap::dof_indices(), libMesh::MeshBase::elem_dimensions(), libMesh::FEGenericBase< OutputType >::get_d2phi(), libMesh::System::get_dof_map(), libMesh::FEGenericBase< OutputType >::get_dphi(), libMesh::FEAbstract::get_JxW(), libMesh::System::get_mesh(), libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::H1, libMesh::H1_SEMINORM, libMesh::H2, libMesh::H2_SEMINORM, libMesh::SystemNorm::is_discrete(), libMesh::L1, libMesh::NumericVector< T >::l1_norm(), libMesh::L2, libMesh::NumericVector< T >::l2_norm(), libMesh::L_INF, libmesh_nullptr, libMesh::NumericVector< T >::linfty_norm(), libMesh::NumericVector< T >::localize(), std::max(), libMesh::Parallel::Communicator::max(), libMesh::QBase::n_points(), libMesh::System::n_vars(), libMesh::TypeVector< T >::norm(), libMesh::TypeTensor< T >::norm(), libMesh::TensorTools::norm_sq(), libMesh::TypeVector< T >::norm_sq(), libMesh::TypeTensor< T >::norm_sq(), libMesh::Real, libMesh::FEAbstract::reinit(), libMesh::SERIAL, libMesh::NumericVector< T >::size(), libMesh::Parallel::Communicator::sum(), libMesh::SystemNorm::type(), libMesh::DofMap::variable_type(), libMesh::W1_INF_SEMINORM, libMesh::W2_INF_SEMINORM, libMesh::SystemNorm::weight(), and libMesh::SystemNorm::weight_sq().

1389 {
1390  // This function must be run on all processors at once
1391  parallel_object_only();
1392 
1393  LOG_SCOPE ("calculate_norm()", "System");
1394 
1395  // Zero the norm before summation
1396  Real v_norm = 0.;
1397 
1398  if (norm.is_discrete())
1399  {
1400  //Check to see if all weights are 1.0 and all types are equal
1401  FEMNormType norm_type0 = norm.type(0);
1402  unsigned int check_var = 0;
1403  for (; check_var != this->n_vars(); ++check_var)
1404  if ((norm.weight(check_var) != 1.0) || (norm.type(check_var) != norm_type0))
1405  break;
1406 
1407  //All weights were 1.0 so just do the full vector discrete norm
1408  if (check_var == this->n_vars())
1409  {
1410  if (norm_type0 == DISCRETE_L1)
1411  return v.l1_norm();
1412  if (norm_type0 == DISCRETE_L2)
1413  return v.l2_norm();
1414  if (norm_type0 == DISCRETE_L_INF)
1415  return v.linfty_norm();
1416  else
1417  libmesh_error_msg("Invalid norm_type0 = " << norm_type0);
1418  }
1419 
1420  for (unsigned int var=0; var != this->n_vars(); ++var)
1421  {
1422  // Skip any variables we don't need to integrate
1423  if (norm.weight(var) == 0.0)
1424  continue;
1425 
1426  v_norm += norm.weight(var) * discrete_var_norm(v, var, norm.type(var));
1427  }
1428 
1429  return v_norm;
1430  }
1431 
1432  // Localize the potentially parallel vector
1433  std::unique_ptr<NumericVector<Number>> local_v = NumericVector<Number>::build(this->comm());
1434  local_v->init(v.size(), true, SERIAL);
1435  v.localize (*local_v, _dof_map->get_send_list());
1436 
1437  // I'm not sure how best to mix Hilbert norms on some variables (for
1438  // which we'll want to square then sum then square root) with norms
1439  // like L_inf (for which we'll just want to take an absolute value
1440  // and then sum).
1441  bool using_hilbert_norm = true,
1442  using_nonhilbert_norm = true;
1443 
1444  // Loop over all variables
1445  for (unsigned int var=0; var != this->n_vars(); ++var)
1446  {
1447  // Skip any variables we don't need to integrate
1448  Real norm_weight_sq = norm.weight_sq(var);
1449  if (norm_weight_sq == 0.0)
1450  continue;
1451  Real norm_weight = norm.weight(var);
1452 
1453  // Check for unimplemented norms (rather than just returning 0).
1454  FEMNormType norm_type = norm.type(var);
1455  if ((norm_type==H1) ||
1456  (norm_type==H2) ||
1457  (norm_type==L2) ||
1458  (norm_type==H1_SEMINORM) ||
1459  (norm_type==H2_SEMINORM))
1460  {
1461  if (!using_hilbert_norm)
1462  libmesh_not_implemented();
1463  using_nonhilbert_norm = false;
1464  }
1465  else if ((norm_type==L1) ||
1466  (norm_type==L_INF) ||
1467  (norm_type==W1_INF_SEMINORM) ||
1468  (norm_type==W2_INF_SEMINORM))
1469  {
1470  if (!using_nonhilbert_norm)
1471  libmesh_not_implemented();
1472  using_hilbert_norm = false;
1473  }
1474  else
1475  libmesh_not_implemented();
1476 
1477  const FEType & fe_type = this->get_dof_map().variable_type(var);
1478 
1479  // Allow space for dims 0-3, even if we don't use them all
1480  std::vector<std::unique_ptr<FEBase>> fe_ptrs(4);
1481  std::vector<std::unique_ptr<QBase>> q_rules(4);
1482 
1483  const std::set<unsigned char> & elem_dims = _mesh.elem_dimensions();
1484 
1485  // Prepare finite elements for each dimension present in the mesh
1486  for (std::set<unsigned char>::const_iterator d_it = elem_dims.begin();
1487  d_it != elem_dims.end(); ++d_it)
1488  {
1489  if (skip_dimensions && skip_dimensions->find(*d_it) != skip_dimensions->end())
1490  continue;
1491 
1492  // Construct quadrature and finite element objects
1493  q_rules[*d_it] = fe_type.default_quadrature_rule (*d_it);
1494  fe_ptrs[*d_it] = FEBase::build(*d_it, fe_type);
1495 
1496  // Attach quadrature rule to FE object
1497  fe_ptrs[*d_it]->attach_quadrature_rule (q_rules[*d_it].get());
1498  }
1499 
1500  std::vector<dof_id_type> dof_indices;
1501 
1502  // Begin the loop over the elements
1503  for (const auto & elem : this->get_mesh().active_local_element_ptr_range())
1504  {
1505  const unsigned int dim = elem->dim();
1506 
1507 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
1508 
1509  // One way for implementing this would be to exchange the fe with the FEInterface- class.
1510  // However, it needs to be discussed whether integral-norms make sense for infinite elements.
1511  // or in which sense they could make sense.
1512  if (elem->infinite() )
1513  libmesh_not_implemented();
1514 
1515 #endif
1516 
1517  if (skip_dimensions && skip_dimensions->find(dim) != skip_dimensions->end())
1518  continue;
1519 
1520  FEBase * fe = fe_ptrs[dim].get();
1521  QBase * qrule = q_rules[dim].get();
1522  libmesh_assert(fe);
1523  libmesh_assert(qrule);
1524 
1525  const std::vector<Real> & JxW = fe->get_JxW();
1526  const std::vector<std::vector<Real>> * phi = libmesh_nullptr;
1527  if (norm_type == H1 ||
1528  norm_type == H2 ||
1529  norm_type == L2 ||
1530  norm_type == L1 ||
1531  norm_type == L_INF)
1532  phi = &(fe->get_phi());
1533 
1534  const std::vector<std::vector<RealGradient>> * dphi = libmesh_nullptr;
1535  if (norm_type == H1 ||
1536  norm_type == H2 ||
1537  norm_type == H1_SEMINORM ||
1538  norm_type == W1_INF_SEMINORM)
1539  dphi = &(fe->get_dphi());
1540 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1541  const std::vector<std::vector<RealTensor>> * d2phi = libmesh_nullptr;
1542  if (norm_type == H2 ||
1543  norm_type == H2_SEMINORM ||
1544  norm_type == W2_INF_SEMINORM)
1545  d2phi = &(fe->get_d2phi());
1546 #endif
1547 
1548  fe->reinit (elem);
1549 
1550  this->get_dof_map().dof_indices (elem, dof_indices, var);
1551 
1552  const unsigned int n_qp = qrule->n_points();
1553 
1554  const unsigned int n_sf = cast_int<unsigned int>
1555  (dof_indices.size());
1556 
1557  // Begin the loop over the Quadrature points.
1558  for (unsigned int qp=0; qp<n_qp; qp++)
1559  {
1560  if (norm_type == L1)
1561  {
1562  Number u_h = 0.;
1563  for (unsigned int i=0; i != n_sf; ++i)
1564  u_h += (*phi)[i][qp] * (*local_v)(dof_indices[i]);
1565  v_norm += norm_weight *
1566  JxW[qp] * std::abs(u_h);
1567  }
1568 
1569  if (norm_type == L_INF)
1570  {
1571  Number u_h = 0.;
1572  for (unsigned int i=0; i != n_sf; ++i)
1573  u_h += (*phi)[i][qp] * (*local_v)(dof_indices[i]);
1574  v_norm = std::max(v_norm, norm_weight * std::abs(u_h));
1575  }
1576 
1577  if (norm_type == H1 ||
1578  norm_type == H2 ||
1579  norm_type == L2)
1580  {
1581  Number u_h = 0.;
1582  for (unsigned int i=0; i != n_sf; ++i)
1583  u_h += (*phi)[i][qp] * (*local_v)(dof_indices[i]);
1584  v_norm += norm_weight_sq *
1585  JxW[qp] * TensorTools::norm_sq(u_h);
1586  }
1587 
1588  if (norm_type == H1 ||
1589  norm_type == H2 ||
1590  norm_type == H1_SEMINORM)
1591  {
1592  Gradient grad_u_h;
1593  for (unsigned int i=0; i != n_sf; ++i)
1594  grad_u_h.add_scaled((*dphi)[i][qp], (*local_v)(dof_indices[i]));
1595  v_norm += norm_weight_sq *
1596  JxW[qp] * grad_u_h.norm_sq();
1597  }
1598 
1599  if (norm_type == W1_INF_SEMINORM)
1600  {
1601  Gradient grad_u_h;
1602  for (unsigned int i=0; i != n_sf; ++i)
1603  grad_u_h.add_scaled((*dphi)[i][qp], (*local_v)(dof_indices[i]));
1604  v_norm = std::max(v_norm, norm_weight * grad_u_h.norm());
1605  }
1606 
1607 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1608  if (norm_type == H2 ||
1609  norm_type == H2_SEMINORM)
1610  {
1611  Tensor hess_u_h;
1612  for (unsigned int i=0; i != n_sf; ++i)
1613  hess_u_h.add_scaled((*d2phi)[i][qp], (*local_v)(dof_indices[i]));
1614  v_norm += norm_weight_sq *
1615  JxW[qp] * hess_u_h.norm_sq();
1616  }
1617 
1618  if (norm_type == W2_INF_SEMINORM)
1619  {
1620  Tensor hess_u_h;
1621  for (unsigned int i=0; i != n_sf; ++i)
1622  hess_u_h.add_scaled((*d2phi)[i][qp], (*local_v)(dof_indices[i]));
1623  v_norm = std::max(v_norm, norm_weight * hess_u_h.norm());
1624  }
1625 #endif
1626  }
1627  }
1628  }
1629 
1630  if (using_hilbert_norm)
1631  {
1632  this->comm().sum(v_norm);
1633  v_norm = std::sqrt(v_norm);
1634  }
1635  else
1636  {
1637  this->comm().max(v_norm);
1638  }
1639 
1640  return v_norm;
1641 }
double abs(double a)
virtual numeric_index_type size() const =0
const FEType & variable_type(const unsigned int c) const
Definition: dof_map.h:1719
void add_scaled(const TypeTensor< T2 > &, const T)
Definition: type_tensor.h:777
void add_scaled(const TypeVector< T2 > &, const T)
Definition: type_vector.h:624
virtual Real l2_norm() const =0
const class libmesh_nullptr_t libmesh_nullptr
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
virtual Real l1_norm() const =0
long double max(long double a, double b)
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
NumberVectorValue Gradient
static std::unique_ptr< FEGenericBase > build(const unsigned int dim, const FEType &type)
const std::set< unsigned char > & elem_dimensions() const
Definition: mesh_base.h:207
FEGenericBase< Real > FEBase
virtual Real linfty_norm() const =0
static std::unique_ptr< NumericVector< T > > build(const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
NumberTensorValue Tensor
const Parallel::Communicator & comm() const
ParallelType type() const
unsigned int n_vars() const
Definition: system.h:2086
MeshBase & _mesh
Definition: system.h:1877
virtual void localize(std::vector< T > &v_local) const =0
Real discrete_var_norm(const NumericVector< Number > &v, unsigned int var, FEMNormType norm_type) const
Definition: system.C:1345
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
Definition: dof_map.C:1924
void libMesh::NonlinearImplicitSystem::clear ( )
virtual

Clear all the data structures associated with the system.

Reimplemented from libMesh::ImplicitSystem.

Definition at line 70 of file nonlinear_implicit_system.C.

References libMesh::ImplicitSystem::clear(), and nonlinear_solver.

Referenced by system(), and ~NonlinearImplicitSystem().

71 {
72  // clear the nonlinear solver
73  nonlinear_solver->clear();
74 
75  // clear the parent data
76  Parent::clear();
77 }
std::unique_ptr< NonlinearSolver< Number > > nonlinear_solver
virtual void clear() libmesh_override
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_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), 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_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::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::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::TopologyMap::init(), libMesh::TimeSolver::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::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::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::LinearPartitioner::partition_range(), 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::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::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::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::split_mesh(), 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
bool libMesh::System::compare ( const System other_system,
const Real  threshold,
const bool  verbose 
) const
virtualinherited
Returns
true when the other system contains identical data, up to the given threshold. Outputs some diagnostic info when verbose is set.

Definition at line 512 of file system.C.

References libMesh::System::_is_initialized, libMesh::System::_sys_name, libMesh::System::_vectors, libMesh::System::get_vector(), libMesh::System::n_vectors(), libMesh::System::name(), libMesh::out, and libMesh::System::solution.

Referenced by libMesh::EquationSystems::compare(), and libMesh::System::set_adjoint_already_solved().

515 {
516  // we do not care for matrices, but for vectors
517  libmesh_assert (_is_initialized);
518  libmesh_assert (other_system._is_initialized);
519 
520  if (verbose)
521  {
522  libMesh::out << " Systems \"" << _sys_name << "\"" << std::endl;
523  libMesh::out << " comparing matrices not supported." << std::endl;
524  libMesh::out << " comparing names...";
525  }
526 
527  // compare the name: 0 means identical
528  const int name_result = _sys_name.compare(other_system.name());
529  if (verbose)
530  {
531  if (name_result == 0)
532  libMesh::out << " identical." << std::endl;
533  else
534  libMesh::out << " names not identical." << std::endl;
535  libMesh::out << " comparing solution vector...";
536  }
537 
538 
539  // compare the solution: -1 means identical
540  const int solu_result = solution->compare (*other_system.solution.get(),
541  threshold);
542 
543  if (verbose)
544  {
545  if (solu_result == -1)
546  libMesh::out << " identical up to threshold." << std::endl;
547  else
548  libMesh::out << " first difference occurred at index = "
549  << solu_result << "." << std::endl;
550  }
551 
552 
553  // safety check, whether we handle at least the same number
554  // of vectors
555  std::vector<int> ov_result;
556 
557  if (this->n_vectors() != other_system.n_vectors())
558  {
559  if (verbose)
560  {
561  libMesh::out << " Fatal difference. This system handles "
562  << this->n_vectors() << " add'l vectors," << std::endl
563  << " while the other system handles "
564  << other_system.n_vectors()
565  << " add'l vectors." << std::endl
566  << " Aborting comparison." << std::endl;
567  }
568  return false;
569  }
570  else if (this->n_vectors() == 0)
571  {
572  // there are no additional vectors...
573  ov_result.clear ();
574  }
575  else
576  {
577  // compare other vectors
578  for (const_vectors_iterator pos = _vectors.begin();
579  pos != _vectors.end(); ++pos)
580  {
581  if (verbose)
582  libMesh::out << " comparing vector \""
583  << pos->first << "\" ...";
584 
585  // assume they have the same name
586  const NumericVector<Number> & other_system_vector =
587  other_system.get_vector(pos->first);
588 
589  ov_result.push_back(pos->second->compare (other_system_vector,
590  threshold));
591 
592  if (verbose)
593  {
594  if (ov_result[ov_result.size()-1] == -1)
595  libMesh::out << " identical up to threshold." << std::endl;
596  else
597  libMesh::out << " first difference occurred at" << std::endl
598  << " index = " << ov_result[ov_result.size()-1] << "." << std::endl;
599  }
600 
601  }
602 
603  } // finished comparing additional vectors
604 
605 
606  bool overall_result;
607 
608  // sum up the results
609  if ((name_result==0) && (solu_result==-1))
610  {
611  if (ov_result.size()==0)
612  overall_result = true;
613  else
614  {
615  bool ov_identical;
616  unsigned int n = 0;
617  do
618  {
619  ov_identical = (ov_result[n]==-1);
620  n++;
621  }
622  while (ov_identical && n<ov_result.size());
623  overall_result = ov_identical;
624  }
625  }
626  else
627  overall_result = false;
628 
629  if (verbose)
630  {
631  libMesh::out << " finished comparisons, ";
632  if (overall_result)
633  libMesh::out << "found no differences." << std::endl << std::endl;
634  else
635  libMesh::out << "found differences." << std::endl << std::endl;
636  }
637 
638  return overall_result;
639 }
bool _is_initialized
Definition: system.h:1952
std::map< std::string, NumericVector< Number > * >::const_iterator const_vectors_iterator
Definition: system.h:735
std::unique_ptr< NumericVector< Number > > solution
Definition: system.h:1509
std::map< std::string, NumericVector< Number > * > _vectors
Definition: system.h:1916
const std::string _sys_name
Definition: system.h:1882
OStreamProxy out(std::cout)
unsigned int n_vectors() const
Definition: system.h:2214
Number libMesh::System::current_solution ( const dof_id_type  global_dof_number) const
inherited
Returns
The current solution for the specified global DOF.

Definition at line 192 of file system.C.

References libMesh::System::_dof_map, and libMesh::System::current_local_solution.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::HPCoarsenTest::add_projection(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::HPCoarsenTest::select_refinement(), libMesh::EnsightIO::write_scalar_ascii(), and libMesh::EnsightIO::write_vector_ascii().

193 {
194  // Check the sizes
195  libmesh_assert_less (global_dof_number, _dof_map->n_dofs());
196  libmesh_assert_less (global_dof_number, current_local_solution->size());
197 
198  return (*current_local_solution)(global_dof_number);
199 }
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
std::unique_ptr< NumericVector< Number > > current_local_solution
Definition: system.h:1521
void libMesh::System::deactivate ( )
inlineinherited

Deactivates the system. Only active systems are solved.

Definition at line 2062 of file system.h.

References libMesh::System::_active.

Referenced by libMesh::System::get_equation_systems().

2063 {
2064  _active = false;
2065 }
void libMesh::ImplicitSystem::disable_cache ( )
virtualinherited

Avoids use of any cached data that might affect any solve result. Should be overridden in derived systems.

Reimplemented from libMesh::System.

Definition at line 313 of file implicit_system.C.

References libMesh::System::assemble_before_solve, libMesh::ImplicitSystem::get_linear_solver(), and libMesh::LinearSolver< T >::reuse_preconditioner().

313  {
314  this->assemble_before_solve = true;
315  this->get_linear_solver()->reuse_preconditioner(false);
316 }
virtual LinearSolver< Number > * get_linear_solver() const
virtual void reuse_preconditioner(bool)
bool assemble_before_solve
Definition: system.h:1463
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 }
Real libMesh::NonlinearImplicitSystem::final_nonlinear_residual ( ) const
inline
Returns
The final residual for the nonlinear system solve.

Definition at line 273 of file nonlinear_implicit_system.h.

References _final_nonlinear_residual, get_current_nonlinear_iteration_number(), and set_solver_parameters().

void libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity ( const QoISet qoi_indices,
const ParameterVector parameters,
SensitivityData sensitivities 
)
virtualinherited

Solves for the derivative of each of the system's quantities of interest q in qoi[qoi_indices] with respect to each parameter in parameters, placing the result for qoi i and parameter j into sensitivities[i][j].

Uses the forward sensitivity method.

Currently uses finite differenced derivatives (partial q / partial p) and (partial R / partial p).

Reimplemented from libMesh::System.

Definition at line 815 of file implicit_system.C.

References std::abs(), libMesh::SensitivityData::allocate_data(), libMesh::ExplicitSystem::assemble_qoi(), libMesh::ExplicitSystem::assemble_qoi_derivative(), libMesh::ImplicitSystem::assembly(), libMesh::NumericVector< T >::close(), libMesh::SparseMatrix< T >::close(), libMesh::NumericVector< T >::dot(), libMesh::System::get_adjoint_rhs(), libMesh::System::get_sensitivity_solution(), libMesh::QoISet::has_index(), libMesh::ImplicitSystem::matrix, std::max(), libMesh::System::qoi, libMesh::Real, libMesh::ExplicitSystem::rhs, libMesh::ImplicitSystem::sensitivity_solve(), libMesh::ParameterVector::size(), and libMesh::TOLERANCE.

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

818 {
819  ParameterVector & parameters =
820  const_cast<ParameterVector &>(parameters_in);
821 
822  const unsigned int Np = cast_int<unsigned int>
823  (parameters.size());
824  const unsigned int Nq = cast_int<unsigned int>
825  (qoi.size());
826 
827  // An introduction to the problem:
828  //
829  // Residual R(u(p),p) = 0
830  // partial R / partial u = J = system matrix
831  //
832  // This implies that:
833  // d/dp(R) = 0
834  // (partial R / partial p) +
835  // (partial R / partial u) * (partial u / partial p) = 0
836 
837  // We first solve for (partial u / partial p) for each parameter:
838  // J * (partial u / partial p) = - (partial R / partial p)
839 
840  this->sensitivity_solve(parameters);
841 
842  // Get ready to fill in sensitivities:
843  sensitivities.allocate_data(qoi_indices, *this, parameters);
844 
845  // We use the identity:
846  // dq/dp = (partial q / partial p) + (partial q / partial u) *
847  // (partial u / partial p)
848 
849  // We get (partial q / partial u) from the user
850  this->assemble_qoi_derivative(qoi_indices,
851  /* include_liftfunc = */ true,
852  /* apply_constraints = */ false);
853 
854  // We don't need these to be closed() in this function, but libMesh
855  // standard practice is to have them closed() by the time the
856  // function exits
857  for (std::size_t i=0; i != this->qoi.size(); ++i)
858  if (qoi_indices.has_index(i))
859  this->get_adjoint_rhs(i).close();
860 
861  for (unsigned int j=0; j != Np; ++j)
862  {
863  // We currently get partial derivatives via central differencing
864 
865  // (partial q / partial p) ~= (q(p+dp)-q(p-dp))/(2*dp)
866 
867  Number old_parameter = *parameters[j];
868 
869  const Real delta_p =
870  TOLERANCE * std::max(std::abs(old_parameter), 1e-3);
871 
872  *parameters[j] = old_parameter - delta_p;
873  this->assemble_qoi(qoi_indices);
874  std::vector<Number> qoi_minus = this->qoi;
875 
876  *parameters[j] = old_parameter + delta_p;
877  this->assemble_qoi(qoi_indices);
878  std::vector<Number> & qoi_plus = this->qoi;
879 
880  std::vector<Number> partialq_partialp(Nq, 0);
881  for (unsigned int i=0; i != Nq; ++i)
882  if (qoi_indices.has_index(i))
883  partialq_partialp[i] = (qoi_plus[i] - qoi_minus[i]) / (2.*delta_p);
884 
885  // Don't leave the parameter changed
886  *parameters[j] = old_parameter;
887 
888  for (unsigned int i=0; i != Nq; ++i)
889  if (qoi_indices.has_index(i))
890  sensitivities[i][j] = partialq_partialp[i] +
891  this->get_adjoint_rhs(i).dot(this->get_sensitivity_solution(j));
892  }
893 
894  // All parameters have been reset.
895  // We didn't cache the original rhs or matrix for memory reasons,
896  // but we can restore them to a state consistent solution -
897  // principle of least surprise.
898  this->assembly(true, true);
899  this->rhs->close();
900  this->matrix->close();
901  this->assemble_qoi(qoi_indices);
902 }
double abs(double a)
NumericVector< Number > & get_sensitivity_solution(unsigned int i=0)
Definition: system.C:917
virtual std::pair< unsigned int, Real > sensitivity_solve(const ParameterVector &parameters) libmesh_override
NumericVector< Number > * rhs
static const Real TOLERANCE
long double max(long double a, double b)
virtual void assemble_qoi_derivative(const QoISet &qoi_indices=QoISet(), bool include_liftfunc=true, bool apply_constraints=true) libmesh_override
virtual void assembly(bool, bool, bool=false, bool=false)
std::vector< Number > qoi
Definition: system.h:1539
virtual void close()=0
virtual void close()=0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
SparseMatrix< Number > * matrix
virtual T dot(const NumericVector< T > &v) const =0
virtual void assemble_qoi(const QoISet &qoi_indices=QoISet()) libmesh_override
NumericVector< Number > & get_adjoint_rhs(unsigned int i=0)
Definition: system.C:1032
NumericVector< Number > & libMesh::System::get_adjoint_rhs ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's adjoint rhs vectors, by default the one corresponding to the first qoi. This what the user's QoI derivative code should assemble when setting up an adjoint problem

Definition at line 1032 of file system.C.

References libMesh::System::get_vector().

Referenced by libMesh::ImplicitSystem::adjoint_solve(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::System::project_solution_on_reinit(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

1033 {
1034  std::ostringstream adjoint_rhs_name;
1035  adjoint_rhs_name << "adjoint_rhs" << i;
1036 
1037  return this->get_vector(adjoint_rhs_name.str());
1038 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
const NumericVector< Number > & libMesh::System::get_adjoint_rhs ( unsigned int  i = 0) const
inherited
Returns
A reference to one of the system's adjoint rhs vectors, by default the one corresponding to the first qoi.

Definition at line 1042 of file system.C.

References libMesh::System::get_vector().

1043 {
1044  std::ostringstream adjoint_rhs_name;
1045  adjoint_rhs_name << "adjoint_rhs" << i;
1046 
1047  return this->get_vector(adjoint_rhs_name.str());
1048 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
NumericVector< Number > & libMesh::System::get_adjoint_solution ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's adjoint solution vectors, by default the one corresponding to the first qoi.

Definition at line 970 of file system.C.

References libMesh::System::get_vector().

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::ImplicitSystem::adjoint_solve(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::System::project_solution_on_reinit(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

971 {
972  std::ostringstream adjoint_name;
973  adjoint_name << "adjoint_solution" << i;
974 
975  return this->get_vector(adjoint_name.str());
976 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
const NumericVector< Number > & libMesh::System::get_adjoint_solution ( unsigned int  i = 0) const
inherited
Returns
A reference to one of the system's adjoint solution vectors, by default the one corresponding to the first qoi.

Definition at line 980 of file system.C.

References libMesh::System::get_vector().

981 {
982  std::ostringstream adjoint_name;
983  adjoint_name << "adjoint_solution" << i;
984 
985  return this->get_vector(adjoint_name.str());
986 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
void libMesh::System::get_all_variable_numbers ( std::vector< unsigned int > &  all_variable_numbers) const
inherited

Fills all_variable_numbers with all the variable numbers for the variables that have been added to this system.

Definition at line 1259 of file system.C.

References libMesh::System::_variable_numbers, and libMesh::System::n_vars().

Referenced by libMesh::System::project_solution_on_reinit().

1260 {
1261  all_variable_numbers.resize(n_vars());
1262 
1263  // Make sure the variable exists
1264  std::map<std::string, unsigned short int>::const_iterator
1265  it = _variable_numbers.begin();
1266  std::map<std::string, unsigned short int>::const_iterator
1267  it_end = _variable_numbers.end();
1268 
1269  unsigned int count = 0;
1270  for ( ; it != it_end; ++it)
1271  {
1272  all_variable_numbers[count] = it->second;
1273  count++;
1274  }
1275 }
std::map< std::string, unsigned short int > _variable_numbers
Definition: system.h:1903
unsigned int n_vars() const
Definition: system.h:2086
unsigned libMesh::NonlinearImplicitSystem::get_current_nonlinear_iteration_number ( ) const

If called during the solve(), for example by the user-specified residual or Jacobian function, return the current nonlinear iteration number.

Definition at line 282 of file nonlinear_implicit_system.C.

References nonlinear_solver.

Referenced by final_nonlinear_residual().

283 {
284  return nonlinear_solver->get_current_nonlinear_iteration_number();
285 }
std::unique_ptr< NonlinearSolver< Number > > nonlinear_solver
const DofMap & libMesh::System::get_dof_map ( ) const
inlineinherited
Returns
A constant reference to this system's _dof_map.

Definition at line 2030 of file system.h.

References libMesh::System::_dof_map.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::DifferentiableSystem::add_dot_var_dirichlet_bcs(), libMesh::HPCoarsenTest::add_projection(), libMesh::UnsteadySolver::adjoint_advance_timestep(), libMesh::ImplicitSystem::adjoint_solve(), libMesh::NewmarkSolver::advance_timestep(), libMesh::UnsteadySolver::advance_timestep(), libMesh::EquationSystems::allgather(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::System::calculate_norm(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), DMCreateDomainDecomposition_libMesh(), DMCreateFieldDecomposition_libMesh(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::System::get_info(), libMesh::EquationSystems::get_solution(), libMesh::SystemSubsetBySubdomain::init(), libMesh::SecondOrderUnsteadySolver::init_data(), libMesh::UnsteadySolver::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ImplicitSystem::init_matrices(), libMesh::CondensedEigenSystem::initialize_condensed_dofs(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::System::local_dof_indices(), libMesh::DofMap::max_constraint_error(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), libMesh::UnsteadySolver::old_nonlinear_solution(), libMesh::SecondOrderUnsteadySolver::old_solution_accel(), libMesh::SecondOrderUnsteadySolver::old_solution_rate(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), libMesh::petsc_auto_fieldsplit(), libMesh::ErrorVector::plot_error(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::FEMContext::pre_fe_reinit(), libMesh::System::re_update(), libMesh::SecondOrderUnsteadySolver::reinit(), libMesh::UnsteadySolver::reinit(), libMesh::ImplicitSystem::reinit(), libMesh::EigenSystem::reinit(), libMesh::System::reinit_constraints(), libMesh::EquationSystems::reinit_solutions(), libMesh::UnsteadySolver::retrieve_timestep(), libMesh::HPCoarsenTest::select_refinement(), libMesh::ImplicitSystem::sensitivity_solve(), libMesh::NewtonSolver::solve(), libMesh::PetscDiffSolver::solve(), libMesh::PetscNonlinearSolver< T >::solve(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), libMesh::ImplicitSystem::weighted_sensitivity_solve(), libMesh::EnsightIO::write_scalar_ascii(), and libMesh::EnsightIO::write_vector_ascii().

2031 {
2032  return *_dof_map;
2033 }
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
DofMap & libMesh::System::get_dof_map ( )
inlineinherited
Returns
A writable reference to this system's _dof_map.

Definition at line 2038 of file system.h.

References libMesh::System::_dof_map.

2039 {
2040  return *_dof_map;
2041 }
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
EquationSystems& libMesh::System::get_equation_systems ( )
inlineinherited
Returns
A reference to this system's parent EquationSystems object.

Definition at line 703 of file system.h.

References libMesh::System::_equation_systems, libMesh::System::activate(), libMesh::System::active(), libMesh::System::deactivate(), and libMesh::System::set_basic_system_only().

703 { return _equation_systems; }
EquationSystems & _equation_systems
Definition: system.h:1871
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
std::string libMesh::System::get_info ( ) const
inherited
Returns
A string containing information about the system.

Definition at line 1645 of file system.C.

References libMesh::FEType::family, libMesh::System::get_dof_map(), libMesh::DofMap::get_info(), libMesh::FEType::inf_map, libMesh::System::n_constrained_dofs(), libMesh::System::n_dofs(), libMesh::System::n_local_constrained_dofs(), libMesh::System::n_local_dofs(), libMesh::System::n_matrices(), libMesh::System::n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::System::n_vectors(), libMesh::VariableGroup::name(), libMesh::System::name(), libMesh::System::number(), libMesh::FEType::order, libMesh::FEType::radial_family, libMesh::FEType::radial_order, libMesh::System::system_type(), libMesh::Variable::type(), libMesh::DofMap::variable_group(), and libMesh::System::variable_group().

Referenced by libMesh::System::read_parallel_data().

1646 {
1647  std::ostringstream oss;
1648 
1649 
1650  const std::string & sys_name = this->name();
1651 
1652  oss << " System #" << this->number() << ", \"" << sys_name << "\"\n"
1653  << " Type \"" << this->system_type() << "\"\n"
1654  << " Variables=";
1655 
1656  for (unsigned int vg=0; vg<this->n_variable_groups(); vg++)
1657  {
1658  const VariableGroup & vg_description (this->variable_group(vg));
1659 
1660  if (vg_description.n_variables() > 1) oss << "{ ";
1661  for (unsigned int vn=0; vn<vg_description.n_variables(); vn++)
1662  oss << "\"" << vg_description.name(vn) << "\" ";
1663  if (vg_description.n_variables() > 1) oss << "} ";
1664  }
1665 
1666  oss << '\n';
1667 
1668  oss << " Finite Element Types=";
1669 #ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
1670  for (unsigned int vg=0; vg<this->n_variable_groups(); vg++)
1671  oss << "\""
1672  << Utility::enum_to_string<FEFamily>(this->get_dof_map().variable_group(vg).type().family)
1673  << "\" ";
1674 #else
1675  for (unsigned int vg=0; vg<this->n_variable_groups(); vg++)
1676  {
1677  oss << "\""
1678  << Utility::enum_to_string<FEFamily>(this->get_dof_map().variable_group(vg).type().family)
1679  << "\", \""
1680  << Utility::enum_to_string<FEFamily>(this->get_dof_map().variable_group(vg).type().radial_family)
1681  << "\" ";
1682  }
1683 
1684  oss << '\n' << " Infinite Element Mapping=";
1685  for (unsigned int vg=0; vg<this->n_variable_groups(); vg++)
1686  oss << "\""
1687  << Utility::enum_to_string<InfMapType>(this->get_dof_map().variable_group(vg).type().inf_map)
1688  << "\" ";
1689 #endif
1690 
1691  oss << '\n';
1692 
1693  oss << " Approximation Orders=";
1694  for (unsigned int vg=0; vg<this->n_variable_groups(); vg++)
1695  {
1696 #ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
1697  oss << "\""
1698  << Utility::enum_to_string<Order>(this->get_dof_map().variable_group(vg).type().order)
1699  << "\" ";
1700 #else
1701  oss << "\""
1702  << Utility::enum_to_string<Order>(this->get_dof_map().variable_group(vg).type().order)
1703  << "\", \""
1704  << Utility::enum_to_string<Order>(this->get_dof_map().variable_group(vg).type().radial_order)
1705  << "\" ";
1706 #endif
1707  }
1708 
1709  oss << '\n';
1710 
1711  oss << " n_dofs()=" << this->n_dofs() << '\n';
1712  oss << " n_local_dofs()=" << this->n_local_dofs() << '\n';
1713 #ifdef LIBMESH_ENABLE_CONSTRAINTS
1714  oss << " n_constrained_dofs()=" << this->n_constrained_dofs() << '\n';
1715  oss << " n_local_constrained_dofs()=" << this->n_local_constrained_dofs() << '\n';
1716 #endif
1717 
1718  oss << " " << "n_vectors()=" << this->n_vectors() << '\n';
1719  oss << " " << "n_matrices()=" << this->n_matrices() << '\n';
1720  // oss << " " << "n_additional_matrices()=" << this->n_additional_matrices() << '\n';
1721 
1722  oss << this->get_dof_map().get_info();
1723 
1724  return oss.str();
1725 }
FEFamily family
Definition: fe_type.h:204
dof_id_type n_constrained_dofs() const
Definition: system.C:155
const FEType & type() const
Definition: variable.h:119
std::string get_info() const
Definition: dof_map.C:2642
OrderWrapper radial_order
Definition: fe_type.h:237
OrderWrapper order
Definition: fe_type.h:198
const VariableGroup & variable_group(unsigned int vg) const
Definition: system.h:2124
const VariableGroup & variable_group(const unsigned int c) const
Definition: dof_map.h:1679
const std::string & name() const
Definition: system.h:1998
unsigned int n_variable_groups() const
Definition: system.h:2094
const DofMap & get_dof_map() const
Definition: system.h:2030
InfMapType inf_map
Definition: fe_type.h:258
virtual unsigned int n_matrices() const
Definition: system.h:2220
FEFamily radial_family
Definition: fe_type.h:250
dof_id_type n_local_dofs() const
Definition: system.C:185
virtual std::string system_type() const
Definition: system.h:473
dof_id_type n_local_constrained_dofs() const
Definition: system.C:170
unsigned int number() const
Definition: system.h:2006
dof_id_type n_dofs() const
Definition: system.C:148
unsigned int n_vectors() const
Definition: system.h:2214
std::pair< unsigned int, Real > libMesh::NonlinearImplicitSystem::get_linear_solve_parameters ( ) const
virtual
Returns
An integer corresponding to the upper iteration count limit and a Real corresponding to the convergence tolerance to be used in linear adjoint and/or sensitivity solves

Reimplemented from libMesh::ImplicitSystem.

Definition at line 200 of file nonlinear_implicit_system.C.

References diff_solver, and nonlinear_solver.

Referenced by system().

201 {
202  if (diff_solver.get())
203  return std::make_pair(this->diff_solver->max_linear_iterations,
204  this->diff_solver->relative_residual_tolerance);
205  return std::make_pair(this->nonlinear_solver->max_linear_iterations,
206  this->nonlinear_solver->relative_residual_tolerance);
207 }
std::unique_ptr< NonlinearSolver< Number > > nonlinear_solver
std::unique_ptr< DiffSolver > diff_solver
LinearSolver< Number > * libMesh::ImplicitSystem::get_linear_solver ( ) const
virtualinherited
Returns
A pointer to a linear solver appropriate for use in adjoint and/or sensitivity solves

This function must be overridden in derived classes, since this base class does not have a valid LinearSolver to hand back a pointer to.

Deprecated:
This function's current behavior, i.e. allocating a LinearSolver and handing it back to the user, makes it very easy to leak memory, and probably won't have the intended effect, i.e. of setting some parameters on a LinearSolver that the System would later use internally.

Reimplemented in libMesh::LinearImplicitSystem, and libMesh::DifferentiableSystem.

Definition at line 1406 of file implicit_system.C.

References libMesh::LinearSolver< T >::build(), libMesh::ParallelObject::comm(), libMesh::LinearSolver< T >::init(), libMesh::System::name(), and libMesh::on_command_line().

Referenced by libMesh::ImplicitSystem::adjoint_solve(), libMesh::ImplicitSystem::disable_cache(), libMesh::ImplicitSystem::sensitivity_solve(), libMesh::ImplicitSystem::system_type(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

1407 {
1408  // This function allocates memory and hands it back to the user as a
1409  // naked pointer. This makes it too easy to leak memory, and
1410  // therefore this function is deprecated. After a period of
1411  // deprecation, this function will eventually be marked with a
1412  // libmesh_error_msg().
1413  libmesh_deprecated();
1414  // libmesh_error_msg("This function should be overridden by derived classes. "
1415  // "It does not contain a valid LinearSolver to hand back to "
1416  // "the user, so it creates one, opening up the possibility "
1417  // "of a memory leak.");
1418 
1419  LinearSolver<Number> * new_solver =
1420  LinearSolver<Number>::build(this->comm()).release();
1421 
1422  if (libMesh::on_command_line("--solver_system_names"))
1423  new_solver->init((this->name()+"_").c_str());
1424  else
1425  new_solver->init();
1426 
1427  return new_solver;
1428 }
static std::unique_ptr< LinearSolver< T > > build(const libMesh::Parallel::Communicator &comm_in, const SolverPackage solver_package=libMesh::default_solver_package())
Definition: linear_solver.C:40
const std::string & name() const
Definition: system.h:1998
bool on_command_line(const std::string &arg)
Definition: libmesh.C:920
const Parallel::Communicator & comm() const
const SparseMatrix< Number > & libMesh::ImplicitSystem::get_matrix ( const std::string &  mat_name) const
inherited
Returns
A const reference to this system's additional matrix named mat_name.

None of these matrices is involved in the solution process. Access is only granted when the matrix is already properly initialized.

Definition at line 270 of file implicit_system.C.

References libMesh::ImplicitSystem::_matrices.

Referenced by libMesh::NewmarkSystem::compute_matrix(), libMesh::EigenTimeSolver::solve(), and libMesh::NewmarkSystem::update_rhs().

271 {
272  // Make sure the matrix exists
273  const_matrices_iterator pos = _matrices.find (mat_name);
274 
275  if (pos == _matrices.end())
276  libmesh_error_msg("ERROR: matrix " << mat_name << " does not exist in this system!");
277 
278  return *(pos->second);
279 }
std::map< std::string, SparseMatrix< Number > * > _matrices
std::map< std::string, SparseMatrix< Number > * >::const_iterator const_matrices_iterator
SparseMatrix< Number > & libMesh::ImplicitSystem::get_matrix ( const std::string &  mat_name)
inherited
Returns
A writable reference to this system's additional matrix named mat_name.

None of these matrices is involved in the solution process. Access is only granted when the matrix is already properly initialized.

Definition at line 283 of file implicit_system.C.

References libMesh::ImplicitSystem::_matrices.

284 {
285  // Make sure the matrix exists
286  matrices_iterator pos = _matrices.find (mat_name);
287 
288  if (pos == _matrices.end())
289  libmesh_error_msg("ERROR: matrix " << mat_name << " does not exist in this system!");
290 
291  return *(pos->second);
292 }
std::map< std::string, SparseMatrix< Number > * > _matrices
std::map< std::string, SparseMatrix< Number > * >::iterator matrices_iterator
const MeshBase & libMesh::System::get_mesh ( ) const
inlineinherited
Returns
A constant reference to this systems's _mesh.

Definition at line 2014 of file system.h.

References libMesh::System::_mesh.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::HPCoarsenTest::add_projection(), libMesh::FEMSystem::assemble_qoi(), libMesh::FEMSystem::assemble_qoi_derivative(), libMesh::FEMSystem::assembly(), libMesh::System::calculate_norm(), DMCreateDomainDecomposition_libMesh(), DMCreateFieldDecomposition_libMesh(), DMlibMeshSetSystem_libMesh(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::SystemSubsetBySubdomain::init(), libMesh::System::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ImplicitSystem::init_matrices(), libMesh::System::local_dof_indices(), libMesh::DofMap::max_constraint_error(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::mesh_position_set(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::FEMSystem::postprocess(), libMesh::ImplicitSystem::reinit(), libMesh::EigenSystem::reinit(), libMesh::HPSingularity::select_refinement(), libMesh::HPCoarsenTest::select_refinement(), and libMesh::System::zero_variable().

2015 {
2016  return _mesh;
2017 }
MeshBase & _mesh
Definition: system.h:1877
MeshBase & libMesh::System::get_mesh ( )
inlineinherited
Returns
A reference to this systems's _mesh.

Definition at line 2022 of file system.h.

References libMesh::System::_mesh.

2023 {
2024  return _mesh;
2025 }
MeshBase & _mesh
Definition: system.h:1877
NumericVector< Number > & libMesh::System::get_sensitivity_rhs ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's sensitivity rhs vectors, by default the one corresponding to the first parameter. By default these vectors are built by the library, using finite differences, when assemble_residual_derivatives() is called.

When assembled, this vector should hold -(partial R / partial p_i)

Definition at line 1062 of file system.C.

References libMesh::System::get_vector().

Referenced by libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::System::project_solution_on_reinit(), and libMesh::ImplicitSystem::sensitivity_solve().

1063 {
1064  std::ostringstream sensitivity_rhs_name;
1065  sensitivity_rhs_name << "sensitivity_rhs" << i;
1066 
1067  return this->get_vector(sensitivity_rhs_name.str());
1068 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
const NumericVector< Number > & libMesh::System::get_sensitivity_rhs ( unsigned int  i = 0) const
inherited
Returns
A reference to one of the system's sensitivity rhs vectors, by default the one corresponding to the first parameter.

Definition at line 1072 of file system.C.

References libMesh::System::get_vector().

1073 {
1074  std::ostringstream sensitivity_rhs_name;
1075  sensitivity_rhs_name << "sensitivity_rhs" << i;
1076 
1077  return this->get_vector(sensitivity_rhs_name.str());
1078 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
NumericVector< Number > & libMesh::System::get_sensitivity_solution ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's solution sensitivity vectors, by default the one corresponding to the first parameter.

Definition at line 917 of file system.C.

References libMesh::System::get_vector().

Referenced by libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::System::project_solution_on_reinit(), libMesh::ImplicitSystem::qoi_parameter_hessian(), and libMesh::ImplicitSystem::sensitivity_solve().

918 {
919  std::ostringstream sensitivity_name;
920  sensitivity_name << "sensitivity_solution" << i;
921 
922  return this->get_vector(sensitivity_name.str());
923 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
const NumericVector< Number > & libMesh::System::get_sensitivity_solution ( unsigned int  i = 0) const
inherited
Returns
A reference to one of the system's solution sensitivity vectors, by default the one corresponding to the first parameter.

Definition at line 927 of file system.C.

References libMesh::System::get_vector().

928 {
929  std::ostringstream sensitivity_name;
930  sensitivity_name << "sensitivity_solution" << i;
931 
932  return this->get_vector(sensitivity_name.str());
933 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
const NumericVector< Number > & libMesh::System::get_vector ( const std::string &  vec_name) const
inherited
Returns
A const reference to this system's additional vector named vec_name. Access is only granted when the vector is already properly initialized.

Definition at line 775 of file system.C.

References libMesh::System::_vectors.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::UnsteadySolver::adjoint_advance_timestep(), libMesh::NewmarkSolver::advance_timestep(), libMesh::AdaptiveTimeSolver::advance_timestep(), libMesh::UnsteadySolver::advance_timestep(), libMesh::System::compare(), libMesh::NewmarkSolver::compute_initial_accel(), libMesh::UnsteadySolver::du(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::System::get_adjoint_rhs(), libMesh::System::get_adjoint_solution(), libMesh::System::get_sensitivity_rhs(), libMesh::System::get_sensitivity_solution(), libMesh::System::get_weighted_sensitivity_adjoint_solution(), libMesh::System::get_weighted_sensitivity_solution(), libMesh::NewmarkSystem::initial_conditions(), libMesh::NewmarkSolver::project_initial_accel(), libMesh::SecondOrderUnsteadySolver::project_initial_rate(), libMesh::System::project_solution_on_reinit(), libMesh::SecondOrderUnsteadySolver::reinit(), libMesh::UnsteadySolver::reinit(), libMesh::MemorySolutionHistory::retrieve(), libMesh::UnsteadySolver::retrieve_timestep(), libMesh::TwostepTimeSolver::solve(), libMesh::TaoOptimizationSolver< T >::solve(), libMesh::NloptOptimizationSolver< T >::solve(), libMesh::FrequencySystem::solve(), libMesh::NewmarkSystem::update_rhs(), and libMesh::NewmarkSystem::update_u_v_a().

776 {
777  // Make sure the vector exists
778  const_vectors_iterator pos = _vectors.find(vec_name);
779 
780  if (pos == _vectors.end())
781  libmesh_error_msg("ERROR: vector " << vec_name << " does not exist in this system!");
782 
783  return *(pos->second);
784 }
std::map< std::string, NumericVector< Number > * >::const_iterator const_vectors_iterator
Definition: system.h:735
std::map< std::string, NumericVector< Number > * > _vectors
Definition: system.h:1916
NumericVector< Number > & libMesh::System::get_vector ( const std::string &  vec_name)
inherited
Returns
A writable reference to this system's additional vector named vec_name. Access is only granted when the vector is already properly initialized.

Definition at line 788 of file system.C.

References libMesh::System::_vectors.

789 {
790  // Make sure the vector exists
791  vectors_iterator pos = _vectors.find(vec_name);
792 
793  if (pos == _vectors.end())
794  libmesh_error_msg("ERROR: vector " << vec_name << " does not exist in this system!");
795 
796  return *(pos->second);
797 }
std::map< std::string, NumericVector< Number > * >::iterator vectors_iterator
Definition: system.h:734
std::map< std::string, NumericVector< Number > * > _vectors
Definition: system.h:1916
const NumericVector< Number > & libMesh::System::get_vector ( const unsigned int  vec_num) const
inherited
Returns
A const reference to this system's additional vector number vec_num (where the vectors are counted starting with 0).

Definition at line 801 of file system.C.

References libMesh::System::vectors_begin(), and libMesh::System::vectors_end().

802 {
805  unsigned int num = 0;
806  while ((num<vec_num) && (v!=v_end))
807  {
808  num++;
809  ++v;
810  }
811  libmesh_assert (v != v_end);
812  return *(v->second);
813 }
vectors_iterator vectors_end()
Definition: system.h:2238
std::map< std::string, NumericVector< Number > * >::const_iterator const_vectors_iterator
Definition: system.h:735
vectors_iterator vectors_begin()
Definition: system.h:2226
NumericVector< Number > & libMesh::System::get_vector ( const unsigned int  vec_num)
inherited
Returns
A writable reference to this system's additional vector number vec_num (where the vectors are counted starting with 0).

Definition at line 817 of file system.C.

References libMesh::System::vectors_begin(), and libMesh::System::vectors_end().

818 {
820  vectors_iterator v_end = vectors_end();
821  unsigned int num = 0;
822  while ((num<vec_num) && (v!=v_end))
823  {
824  num++;
825  ++v;
826  }
827  libmesh_assert (v != v_end);
828  return *(v->second);
829 }
vectors_iterator vectors_end()
Definition: system.h:2238
vectors_iterator vectors_begin()
Definition: system.h:2226
std::map< std::string, NumericVector< Number > * >::iterator vectors_iterator
Definition: system.h:734
NumericVector< Number > & libMesh::System::get_weighted_sensitivity_adjoint_solution ( unsigned int  i = 0)
inherited
Returns
A reference to one of the system's weighted sensitivity adjoint solution vectors, by default the one corresponding to the first qoi.

Definition at line 1002 of file system.C.

References libMesh::System::get_vector().

Referenced by libMesh::System::project_solution_on_reinit(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

1003 {
1004  std::ostringstream adjoint_name;
1005  adjoint_name << "weighted_sensitivity_adjoint_solution" << i;
1006 
1007  return this->get_vector(adjoint_name.str());
1008 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
const NumericVector< Number > & libMesh::System::get_weighted_sensitivity_adjoint_solution ( unsigned int  i = 0) const
inherited
Returns
A reference to one of the system's weighted sensitivity adjoint solution vectors, by default the one corresponding to the first qoi.

Definition at line 1012 of file system.C.

References libMesh::System::get_vector().

1013 {
1014  std::ostringstream adjoint_name;
1015  adjoint_name << "weighted_sensitivity_adjoint_solution" << i;
1016 
1017  return this->get_vector(adjoint_name.str());
1018 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
NumericVector< Number > & libMesh::System::get_weighted_sensitivity_solution ( )
inherited
Returns
A reference to the solution of the last weighted sensitivity solve

Definition at line 944 of file system.C.

References libMesh::System::get_vector().

Referenced by libMesh::System::project_solution_on_reinit(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

945 {
946  return this->get_vector("weighted_sensitivity_solution");
947 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
const NumericVector< Number > & libMesh::System::get_weighted_sensitivity_solution ( ) const
inherited
Returns
A reference to the solution of the last weighted sensitivity solve

Definition at line 951 of file system.C.

References libMesh::System::get_vector().

952 {
953  return this->get_vector("weighted_sensitivity_solution");
954 }
const NumericVector< Number > & get_vector(const std::string &vec_name) const
Definition: system.C:775
bool libMesh::System::has_variable ( const std::string &  var) const
inherited
Returns
true if a variable named var exists in this System

Definition at line 1237 of file system.C.

References libMesh::System::_variable_numbers.

Referenced by libMesh::GMVIO::copy_nodal_solution(), and libMesh::System::project_solution_on_reinit().

1238 {
1239  return _variable_numbers.count(var);
1240 }
std::map< std::string, unsigned short int > _variable_numbers
Definition: system.h:1903
bool libMesh::ImplicitSystem::have_matrix ( const std::string &  mat_name) const
inlineinherited
Returns
true if this System has a matrix associated with the given name, false otherwise.

Definition at line 403 of file implicit_system.h.

Referenced by libMesh::ImplicitSystem::add_matrix(), and libMesh::EigenTimeSolver::init().

404 {
405  return (_matrices.count(mat_name));
406 }
std::map< std::string, SparseMatrix< Number > * > _matrices
bool libMesh::System::have_vector ( const std::string &  vec_name) const
inlineinherited
Returns
true if this System has a vector associated with the given name, false otherwise.

Definition at line 2206 of file system.h.

References libMesh::System::_vectors.

Referenced by libMesh::System::add_vector(), and libMesh::System::project_solution_on_reinit().

2207 {
2208  return (_vectors.count(vec_name));
2209 }
std::map< std::string, NumericVector< Number > * > _vectors
Definition: system.h:1916
bool libMesh::System::identify_variable_groups ( ) const
inlineinherited
Returns
true when VariableGroup structures should be automatically identified, false otherwise.

Definition at line 2182 of file system.h.

References libMesh::System::_identify_variable_groups.

Referenced by libMesh::System::add_variable(), and libMesh::System::project_solution_on_reinit().

2183 {
2185 }
bool _identify_variable_groups
Definition: system.h:1958
void libMesh::System::identify_variable_groups ( const bool  ivg)
inlineinherited

Toggle automatic VariableGroup identification.

Definition at line 2190 of file system.h.

References libMesh::System::_identify_variable_groups.

2191 {
2193 }
bool _identify_variable_groups
Definition: system.h:1958
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
void libMesh::System::init ( )
inherited

Initializes degrees of freedom on the current mesh. Sets the

Definition at line 235 of file system.C.

References libMesh::System::_basic_system_only, libMesh::System::init_data(), libMesh::System::is_initialized(), libMesh::System::n_vars(), and libMesh::System::user_initialization().

Referenced by libMesh::System::system().

236 {
237  // Calling init() twice on the same system currently works evil
238  // magic, whether done directly or via EquationSystems::read()
239  libmesh_assert(!this->is_initialized());
240 
241  // First initialize any required data:
242  // either only the basic System data
243  if (_basic_system_only)
245  // or all the derived class' data too
246  else
247  this->init_data();
248 
249  // If no variables have been added to this system
250  // don't do anything
251  if (!this->n_vars())
252  return;
253 
254  // Then call the user-provided initialization function
255  this->user_initialization();
256 }
bool _basic_system_only
Definition: system.h:1946
virtual void init_data()
Definition: system.C:260
virtual void user_initialization()
Definition: system.C:1905
bool is_initialized()
Definition: system.h:2070
unsigned int n_vars() const
Definition: system.h:2086
void libMesh::ImplicitSystem::init_data ( )
protectedvirtualinherited

Initializes the member data fields associated with the system, so that, e.g., assemble() may be used.

Reimplemented from libMesh::System.

Reimplemented in libMesh::DifferentiableSystem, libMesh::ContinuationSystem, libMesh::RBEIMConstruction, libMesh::FEMSystem, libMesh::OptimizationSystem, libMesh::FrequencySystem, libMesh::RBConstructionBase< LinearImplicitSystem >, and libMesh::LinearImplicitSystem.

Definition at line 91 of file implicit_system.C.

References libMesh::ImplicitSystem::_matrices, libMesh::System::init_data(), and libMesh::ImplicitSystem::init_matrices().

Referenced by libMesh::LinearImplicitSystem::init_data(), libMesh::OptimizationSystem::init_data(), and libMesh::DifferentiableSystem::init_data().

92 {
93  // initialize parent data
95 
96  // Clear any existing matrices
97  for (matrices_iterator pos = _matrices.begin();
98  pos != _matrices.end(); ++pos)
99  pos->second->clear();
100 
101  // Initialize the matrices for the system
102  this->init_matrices ();
103 }
virtual void init_data()
Definition: system.C:260
std::map< std::string, SparseMatrix< Number > * > _matrices
std::map< std::string, SparseMatrix< Number > * >::iterator matrices_iterator
virtual void init_matrices()
void libMesh::ImplicitSystem::init_matrices ( )
protectedvirtualinherited

Initializes the matrices associated with this system.

Definition at line 107 of file implicit_system.C.

References libMesh::ImplicitSystem::_can_add_matrices, libMesh::ImplicitSystem::_matrices, libMesh::DofMap::attach_matrix(), libMesh::DofMap::compute_sparsity(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), libMesh::SparseMatrix< T >::initialized(), libMesh::DofMap::is_attached(), and libMesh::ImplicitSystem::matrix.

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

108 {
109  libmesh_assert(matrix);
110 
111  // Check for quick return in case the system matrix
112  // (and by extension all the matrices) has already
113  // been initialized
114  if (matrix->initialized())
115  return;
116 
117  // Get a reference to the DofMap
118  DofMap & dof_map = this->get_dof_map();
119 
120  // no chance to add other matrices
121  _can_add_matrices = false;
122 
123  // Tell the matrices about the dof map, and vice versa
124  for (matrices_iterator pos = _matrices.begin();
125  pos != _matrices.end(); ++pos)
126  {
127  SparseMatrix<Number> & m = *(pos->second);
128  libmesh_assert (!m.initialized());
129 
130  // We want to allow repeated init() on systems, but we don't
131  // want to attach the same matrix to the DofMap twice
132  if (!dof_map.is_attached(m))
133  dof_map.attach_matrix (m);
134  }
135 
136  // Compute the sparsity pattern for the current
137  // mesh and DOF distribution. This also updates
138  // additional matrices, \p DofMap now knows them
139  dof_map.compute_sparsity (this->get_mesh());
140 
141  // Initialize matrices
142  for (matrices_iterator pos = _matrices.begin();
143  pos != _matrices.end(); ++pos)
144  pos->second->init ();
145 
146  // Set the additional matrices to 0.
147  for (matrices_iterator pos = _matrices.begin();
148  pos != _matrices.end(); ++pos)
149  pos->second->zero ();
150 }
std::map< std::string, SparseMatrix< Number > * > _matrices
virtual bool initialized() const
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
SparseMatrix< Number > * matrix
std::map< std::string, SparseMatrix< Number > * >::iterator matrices_iterator
bool libMesh::System::is_initialized ( )
inlineinherited
Returns
true iff this system has been initialized.

Definition at line 2070 of file system.h.

References libMesh::System::_is_initialized.

Referenced by libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::init(), and libMesh::System::system().

2071 {
2072  return _is_initialized;
2073 }
bool _is_initialized
Definition: system.h:1952
void libMesh::System::local_dof_indices ( const unsigned int  var,
std::set< dof_id_type > &  var_indices 
) const
inherited

Fills the std::set with the degrees of freedom on the local processor corresponding the the variable number passed in.

Definition at line 1278 of file system.C.

References libMesh::DofMap::dof_indices(), libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), libMesh::System::get_dof_map(), and libMesh::System::get_mesh().

Referenced by libMesh::System::discrete_var_norm().

1280 {
1281  // Make sure the set is clear
1282  var_indices.clear();
1283 
1284  std::vector<dof_id_type> dof_indices;
1285 
1286  const dof_id_type
1287  first_local = this->get_dof_map().first_dof(),
1288  end_local = this->get_dof_map().end_dof();
1289 
1290  // Begin the loop over the elements
1291  for (const auto & elem : this->get_mesh().active_local_element_ptr_range())
1292  {
1293  this->get_dof_map().dof_indices (elem, dof_indices, var);
1294 
1295  for (std::size_t i=0; i<dof_indices.size(); i++)
1296  {
1297  dof_id_type dof = dof_indices[i];
1298 
1299  //If the dof is owned by the local processor
1300  if (first_local <= dof && dof < end_local)
1301  var_indices.insert(dof_indices[i]);
1302  }
1303  }
1304 }
dof_id_type first_dof(const processor_id_type proc) const
Definition: dof_map.h:544
dof_id_type end_dof(const processor_id_type proc) const
Definition: dof_map.h:586
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
uint8_t dof_id_type
Definition: id_types.h:64
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
Definition: dof_map.C:1924
dof_id_type libMesh::System::n_active_dofs ( ) const
inlineinherited
Returns
The number of active degrees of freedom for this System.

Definition at line 2198 of file system.h.

References libMesh::System::n_constrained_dofs(), and libMesh::System::n_dofs().

Referenced by libMesh::System::project_solution_on_reinit().

2199 {
2200  return this->n_dofs() - this->n_constrained_dofs();
2201 }
dof_id_type n_constrained_dofs() const
Definition: system.C:155
dof_id_type n_dofs() const
Definition: system.C:148
unsigned int libMesh::System::n_components ( ) const
inlineinherited
Returns
The total number of scalar components in the system's variables. This will equal n_vars() in the case of all scalar-valued variables.

Definition at line 2102 of file system.h.

References libMesh::System::_variables, libMesh::Variable::first_scalar_number(), and libMesh::Variable::n_components().

Referenced by libMesh::System::add_variables(), libMesh::WrappedFunction< Output >::operator()(), and libMesh::System::project_solution_on_reinit().

2103 {
2104  if (_variables.empty())
2105  return 0;
2106 
2107  const Variable & last = _variables.back();
2108  return last.first_scalar_number() + last.n_components();
2109 }
std::vector< Variable > _variables
Definition: system.h:1892
dof_id_type libMesh::System::n_constrained_dofs ( ) const
inherited
Returns
The total number of constrained degrees of freedom in the system.

Definition at line 155 of file system.C.

References libMesh::System::_dof_map.

Referenced by libMesh::System::get_info(), libMesh::System::n_active_dofs(), and libMesh::System::project_solution_on_reinit().

156 {
157 #ifdef LIBMESH_ENABLE_CONSTRAINTS
158 
159  return _dof_map->n_constrained_dofs();
160 
161 #else
162 
163  return 0;
164 
165 #endif
166 }
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
dof_id_type libMesh::System::n_local_constrained_dofs ( ) const
inherited
Returns
The number of constrained degrees of freedom on this processor.

Definition at line 170 of file system.C.

References libMesh::System::_dof_map.

Referenced by libMesh::System::get_info(), and libMesh::System::project_solution_on_reinit().

171 {
172 #ifdef LIBMESH_ENABLE_CONSTRAINTS
173 
174  return _dof_map->n_local_constrained_dofs();
175 
176 #else
177 
178  return 0;
179 
180 #endif
181 }
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
unsigned int libMesh::ImplicitSystem::n_matrices ( ) const
inlinevirtualinherited
Returns
The number of matrices handled by this system

Reimplemented from libMesh::System.

Definition at line 410 of file implicit_system.h.

References libMesh::ImplicitSystem::_matrices.

411 {
412  return cast_int<unsigned int>(_matrices.size());
413 }
std::map< std::string, SparseMatrix< Number > * > _matrices
unsigned int libMesh::NonlinearImplicitSystem::n_nonlinear_iterations ( ) const
inline
Returns
The number of iterations taken for the most recent nonlinear solve.

Definition at line 268 of file nonlinear_implicit_system.h.

References _n_nonlinear_iterations.

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::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), 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:725
const Parallel::Communicator & _communicator
unsigned int libMesh::System::n_variable_groups ( ) const
inlineinherited
Returns
The number of VariableGroup variable groups in the system

Definition at line 2094 of file system.h.

References libMesh::System::_variable_groups.

Referenced by libMesh::System::add_variable(), libMesh::FEMSystem::assembly(), libMesh::System::get_info(), libMesh::System::init_data(), and libMesh::System::project_solution_on_reinit().

2095 {
2096  return cast_int<unsigned int>(_variable_groups.size());
2097 }
std::vector< VariableGroup > _variable_groups
Definition: system.h:1897
unsigned int libMesh::System::n_vars ( ) const
inlineinherited
Returns
The number of variables in the system

Definition at line 2086 of file system.h.

References libMesh::System::_variables.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::DiffContext::add_localized_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::System::calculate_norm(), libMesh::WrappedFunction< Output >::component(), libMesh::DGFEMContext::DGFEMContext(), libMesh::DiffContext::DiffContext(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactSolution::ExactSolution(), libMesh::System::get_all_variable_numbers(), libMesh::EquationSystems::get_solution(), libMesh::System::init(), libMesh::FEMSystem::init_context(), libMesh::FEMContext::init_internal_data(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), libMesh::WrappedFunction< Output >::operator()(), libMesh::petsc_auto_fieldsplit(), libMesh::FEMContext::pre_fe_reinit(), libMesh::System::project_solution_on_reinit(), libMesh::System::re_update(), libMesh::HPCoarsenTest::select_refinement(), libMesh::SystemSubsetBySubdomain::set_var_nums(), and libMesh::System::zero_variable().

2087 {
2088  return cast_int<unsigned int>(_variables.size());
2089 }
std::vector< Variable > _variables
Definition: system.h:1892
unsigned int libMesh::System::n_vectors ( ) const
inlineinherited
Returns
The number of vectors (in addition to the solution) handled by this system This is the size of the _vectors map

Definition at line 2214 of file system.h.

References libMesh::System::_vectors.

Referenced by libMesh::ExplicitSystem::add_system_rhs(), libMesh::System::compare(), libMesh::System::get_info(), and libMesh::System::project_solution_on_reinit().

2215 {
2216  return cast_int<unsigned int>(_vectors.size());
2217 }
std::map< std::string, NumericVector< Number > * > _vectors
Definition: system.h:1916
Gradient libMesh::System::point_gradient ( unsigned int  var,
const Point p,
const bool  insist_on_success = true 
) const
inherited
Returns
The gradient of the solution variable var at the physical point p in the mesh, similarly to point_value.

Definition at line 2087 of file system.C.

References libMesh::Parallel::Communicator::broadcast(), libMesh::ParallelObject::comm(), libMesh::PointLocatorBase::enable_out_of_mesh_mode(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), libMesh::MeshBase::is_serial(), mesh, libMesh::Parallel::Communicator::min(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::MeshBase::sub_point_locator(), and libMesh::Parallel::verify().

Referenced by libMesh::System::point_gradient().

2088 {
2089  // This function must be called on every processor; there's no
2090  // telling where in the partition p falls.
2091  parallel_object_only();
2092 
2093  // And every processor had better agree about which point we're
2094  // looking for
2095 #ifndef NDEBUG
2096  libmesh_assert(this->comm().verify(p(0)));
2097 #if LIBMESH_DIM > 1
2098  libmesh_assert(this->comm().verify(p(1)));
2099 #endif
2100 #if LIBMESH_DIM > 2
2101  libmesh_assert(this->comm().verify(p(2)));
2102 #endif
2103 #endif // NDEBUG
2104 
2105  // Get a reference to the mesh object associated with the system object that calls this function
2106  const MeshBase & mesh = this->get_mesh();
2107 
2108  // Use an existing PointLocator or create a new one
2109  std::unique_ptr<PointLocatorBase> locator_ptr = mesh.sub_point_locator();
2110  PointLocatorBase & locator = *locator_ptr;
2111 
2112  if (!insist_on_success || !mesh.is_serial())
2113  locator.enable_out_of_mesh_mode();
2114 
2115  // Get a pointer to the element that contains P
2116  const Elem * e = locator(p);
2117 
2118  Gradient grad_u;
2119 
2120  if (e && this->get_dof_map().is_evaluable(*e, var))
2121  grad_u = point_gradient(var, p, *e);
2122 
2123  // If I have an element containing p, then let's let everyone know
2124  processor_id_type lowest_owner =
2125  (e && (e->processor_id() == this->processor_id())) ?
2126  this->processor_id() : this->n_processors();
2127  this->comm().min(lowest_owner);
2128 
2129  // Everybody should get their value from a processor that was able
2130  // to compute it.
2131  // If nobody admits owning the point, we may have a problem.
2132  if (lowest_owner != this->n_processors())
2133  this->comm().broadcast(grad_u, lowest_owner);
2134  else
2135  libmesh_assert(!insist_on_success);
2136 
2137  return grad_u;
2138 }
processor_id_type n_processors() const
MeshBase & mesh
uint8_t processor_id_type
Definition: id_types.h:99
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
NumberVectorValue Gradient
void broadcast(T &data, const unsigned int root_id=0) const
Gradient point_gradient(unsigned int var, const Point &p, const bool insist_on_success=true) const
Definition: system.C:2087
bool verify(const T &r, const Communicator &comm=Communicator_World)
const Parallel::Communicator & comm() const
processor_id_type processor_id() const
Gradient libMesh::System::point_gradient ( unsigned int  var,
const Point p,
const Elem e 
) const
inherited
Returns
The gradient of the solution variable var at the physical point p in local Elem e in the mesh, similarly to point_value.

Definition at line 2141 of file system.C.

References libMesh::TypeVector< T >::add_scaled(), libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::contains_point(), libMesh::System::current_solution(), libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), libMesh::System::get_dof_map(), libMesh::Elem::infinite(), libMesh::FEInterface::inverse_map(), libMesh::DofMap::is_evaluable(), and libMesh::DofMap::variable_type().

2142 {
2143  // Ensuring that the given point is really in the element is an
2144  // expensive assert, but as long as debugging is turned on we might
2145  // as well try to catch a particularly nasty potential error
2146  libmesh_assert (e.contains_point(p));
2147 
2148 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
2149  if (e.infinite())
2150  libmesh_not_implemented();
2151 #endif
2152 
2153  // Get the dof map to get the proper indices for our computation
2154  const DofMap & dof_map = this->get_dof_map();
2155 
2156  // Make sure we can evaluate on this element.
2157  libmesh_assert (dof_map.is_evaluable(e, var));
2158 
2159  // Need dof_indices for phi[i][j]
2160  std::vector<dof_id_type> dof_indices;
2161 
2162  // Fill in the dof_indices for our element
2163  dof_map.dof_indices (&e, dof_indices, var);
2164 
2165  // Get the no of dofs associated with this point
2166  const unsigned int num_dofs = cast_int<unsigned int>
2167  (dof_indices.size());
2168 
2169  FEType fe_type = dof_map.variable_type(var);
2170 
2171  // Build a FE again so we can calculate u(p)
2172  std::unique_ptr<FEBase> fe (FEBase::build(e.dim(), fe_type));
2173 
2174  // Map the physical co-ordinates to the master co-ordinates using the inverse_map from fe_interface.h
2175  // Build a vector of point co-ordinates to send to reinit
2176  std::vector<Point> coor(1, FEInterface::inverse_map(e.dim(), fe_type, &e, p));
2177 
2178  // Get the values of the shape function derivatives
2179  const std::vector<std::vector<RealGradient>> & dphi = fe->get_dphi();
2180 
2181  // Reinitialize the element and compute the shape function values at coor
2182  fe->reinit (&e, &coor);
2183 
2184  // Get ready to accumulate a gradient
2185  Gradient grad_u;
2186 
2187  for (unsigned int l=0; l<num_dofs; l++)
2188  {
2189  grad_u.add_scaled (dphi[l][0], this->current_solution (dof_indices[l]));
2190  }
2191 
2192  return grad_u;
2193 }
void add_scaled(const TypeVector< T2 > &, const T)
Definition: type_vector.h:624
const DofMap & get_dof_map() const
Definition: system.h:2030
NumberVectorValue Gradient
static std::unique_ptr< FEGenericBase > build(const unsigned int dim, const FEType &type)
static Point inverse_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: fe_interface.C:547
Number current_solution(const dof_id_type global_dof_number) const
Definition: system.C:192
Gradient libMesh::System::point_gradient ( unsigned int  var,
const Point p,
const Elem e 
) const
inherited

Calls the version of point_gradient() which takes a reference. This function exists only to prevent people from calling the version of point_gradient() that has a boolean third argument, which would result in unnecessary PointLocator calls.

Definition at line 2197 of file system.C.

References libMesh::System::point_gradient().

2198 {
2199  libmesh_assert(e);
2200  return this->point_gradient(var, p, *e);
2201 }
Gradient point_gradient(unsigned int var, const Point &p, const bool insist_on_success=true) const
Definition: system.C:2087
Tensor libMesh::System::point_hessian ( unsigned int  var,
const Point p,
const bool  insist_on_success = true 
) const
inherited
Returns
The second derivative tensor of the solution variable var at the physical point p in the mesh, similarly to point_value.

Definition at line 2207 of file system.C.

References libMesh::Parallel::Communicator::broadcast(), libMesh::ParallelObject::comm(), libMesh::PointLocatorBase::enable_out_of_mesh_mode(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), libMesh::MeshBase::is_serial(), mesh, libMesh::Parallel::Communicator::min(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::MeshBase::sub_point_locator(), and libMesh::Parallel::verify().

Referenced by libMesh::System::point_hessian().

2208 {
2209  // This function must be called on every processor; there's no
2210  // telling where in the partition p falls.
2211  parallel_object_only();
2212 
2213  // And every processor had better agree about which point we're
2214  // looking for
2215 #ifndef NDEBUG
2216  libmesh_assert(this->comm().verify(p(0)));
2217 #if LIBMESH_DIM > 1
2218  libmesh_assert(this->comm().verify(p(1)));
2219 #endif
2220 #if LIBMESH_DIM > 2
2221  libmesh_assert(this->comm().verify(p(2)));
2222 #endif
2223 #endif // NDEBUG
2224 
2225  // Get a reference to the mesh object associated with the system object that calls this function
2226  const MeshBase & mesh = this->get_mesh();
2227 
2228  // Use an existing PointLocator or create a new one
2229  std::unique_ptr<PointLocatorBase> locator_ptr = mesh.sub_point_locator();
2230  PointLocatorBase & locator = *locator_ptr;
2231 
2232  if (!insist_on_success || !mesh.is_serial())
2233  locator.enable_out_of_mesh_mode();
2234 
2235  // Get a pointer to the element that contains P
2236  const Elem * e = locator(p);
2237 
2238  Tensor hess_u;
2239 
2240  if (e && this->get_dof_map().is_evaluable(*e, var))
2241  hess_u = point_hessian(var, p, *e);
2242 
2243  // If I have an element containing p, then let's let everyone know
2244  processor_id_type lowest_owner =
2245  (e && (e->processor_id() == this->processor_id())) ?
2246  this->processor_id() : this->n_processors();
2247  this->comm().min(lowest_owner);
2248 
2249  // Everybody should get their value from a processor that was able
2250  // to compute it.
2251  // If nobody admits owning the point, we may have a problem.
2252  if (lowest_owner != this->n_processors())
2253  this->comm().broadcast(hess_u, lowest_owner);
2254  else
2255  libmesh_assert(!insist_on_success);
2256 
2257  return hess_u;
2258 }
processor_id_type n_processors() const
MeshBase & mesh
uint8_t processor_id_type
Definition: id_types.h:99
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
Tensor point_hessian(unsigned int var, const Point &p, const bool insist_on_success=true) const
Definition: system.C:2207
void broadcast(T &data, const unsigned int root_id=0) const
bool verify(const T &r, const Communicator &comm=Communicator_World)
NumberTensorValue Tensor
const Parallel::Communicator & comm() const
processor_id_type processor_id() const
Tensor libMesh::System::point_hessian ( unsigned int  var,
const Point p,
const Elem e 
) const
inherited
Returns
The second derivative tensor of the solution variable var at the physical point p in local Elem e in the mesh, similarly to point_value.

Definition at line 2260 of file system.C.

References libMesh::TypeTensor< T >::add_scaled(), libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::contains_point(), libMesh::System::current_solution(), libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), libMesh::System::get_dof_map(), libMesh::Elem::infinite(), libMesh::FEInterface::inverse_map(), libMesh::DofMap::is_evaluable(), and libMesh::DofMap::variable_type().

2261 {
2262  // Ensuring that the given point is really in the element is an
2263  // expensive assert, but as long as debugging is turned on we might
2264  // as well try to catch a particularly nasty potential error
2265  libmesh_assert (e.contains_point(p));
2266 
2267 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
2268  if (e.infinite())
2269  libmesh_not_implemented();
2270 #endif
2271 
2272  // Get the dof map to get the proper indices for our computation
2273  const DofMap & dof_map = this->get_dof_map();
2274 
2275  // Make sure we can evaluate on this element.
2276  libmesh_assert (dof_map.is_evaluable(e, var));
2277 
2278  // Need dof_indices for phi[i][j]
2279  std::vector<dof_id_type> dof_indices;
2280 
2281  // Fill in the dof_indices for our element
2282  dof_map.dof_indices (&e, dof_indices, var);
2283 
2284  // Get the no of dofs associated with this point
2285  const unsigned int num_dofs = cast_int<unsigned int>
2286  (dof_indices.size());
2287 
2288  FEType fe_type = dof_map.variable_type(var);
2289 
2290  // Build a FE again so we can calculate u(p)
2291  std::unique_ptr<FEBase> fe (FEBase::build(e.dim(), fe_type));
2292 
2293  // Map the physical co-ordinates to the master co-ordinates using the inverse_map from fe_interface.h
2294  // Build a vector of point co-ordinates to send to reinit
2295  std::vector<Point> coor(1, FEInterface::inverse_map(e.dim(), fe_type, &e, p));
2296 
2297  // Get the values of the shape function derivatives
2298  const std::vector<std::vector<RealTensor>> & d2phi = fe->get_d2phi();
2299 
2300  // Reinitialize the element and compute the shape function values at coor
2301  fe->reinit (&e, &coor);
2302 
2303  // Get ready to accumulate a hessian
2304  Tensor hess_u;
2305 
2306  for (unsigned int l=0; l<num_dofs; l++)
2307  {
2308  hess_u.add_scaled (d2phi[l][0], this->current_solution (dof_indices[l]));
2309  }
2310 
2311  return hess_u;
2312 }
void add_scaled(const TypeTensor< T2 > &, const T)
Definition: type_tensor.h:777
const DofMap & get_dof_map() const
Definition: system.h:2030
static std::unique_ptr< FEGenericBase > build(const unsigned int dim, const FEType &type)
static Point inverse_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: fe_interface.C:547
Number current_solution(const dof_id_type global_dof_number) const
Definition: system.C:192
NumberTensorValue Tensor
Tensor libMesh::System::point_hessian ( unsigned int  var,
const Point p,
const Elem e 
) const
inherited

Calls the version of point_hessian() which takes a reference. This function exists only to prevent people from calling the version of point_hessian() that has a boolean third argument, which would result in unnecessary PointLocator calls.

Definition at line 2316 of file system.C.

References libMesh::System::point_hessian().

2317 {
2318  libmesh_assert(e);
2319  return this->point_hessian(var, p, *e);
2320 }
Tensor point_hessian(unsigned int var, const Point &p, const bool insist_on_success=true) const
Definition: system.C:2207
Number libMesh::System::point_value ( unsigned int  var,
const Point p,
const bool  insist_on_success = true 
) const
inherited
Returns
The value of the solution variable var at the physical point p in the mesh, without knowing a priori which element contains p.
Note
This function uses MeshBase::sub_point_locator(); users may or may not want to call MeshBase::clear_point_locator() afterward. Also, point_locator() is expensive (N log N for initial construction, log N for evaluations). Avoid using this function in any context where you are already looping over elements.

Because the element containing p may lie on any processor, this function is parallel-only.

By default this method expects the point to reside inside the domain and will abort if no element can be found which contains p. The optional parameter insist_on_success can be set to false to allow the method to return 0 when the point is not located.

Definition at line 1980 of file system.C.

References libMesh::Parallel::Communicator::broadcast(), libMesh::ParallelObject::comm(), libMesh::PointLocatorBase::enable_out_of_mesh_mode(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), libMesh::MeshBase::is_serial(), mesh, libMesh::Parallel::Communicator::min(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::MeshBase::sub_point_locator(), and libMesh::Parallel::verify().

Referenced by libMesh::System::point_value().

1981 {
1982  // This function must be called on every processor; there's no
1983  // telling where in the partition p falls.
1984  parallel_object_only();
1985 
1986  // And every processor had better agree about which point we're
1987  // looking for
1988 #ifndef NDEBUG
1989  libmesh_assert(this->comm().verify(p(0)));
1990 #if LIBMESH_DIM > 1
1991  libmesh_assert(this->comm().verify(p(1)));
1992 #endif
1993 #if LIBMESH_DIM > 2
1994  libmesh_assert(this->comm().verify(p(2)));
1995 #endif
1996 #endif // NDEBUG
1997 
1998  // Get a reference to the mesh object associated with the system object that calls this function
1999  const MeshBase & mesh = this->get_mesh();
2000 
2001  // Use an existing PointLocator or create a new one
2002  std::unique_ptr<PointLocatorBase> locator_ptr = mesh.sub_point_locator();
2003  PointLocatorBase & locator = *locator_ptr;
2004 
2005  if (!insist_on_success || !mesh.is_serial())
2006  locator.enable_out_of_mesh_mode();
2007 
2008  // Get a pointer to the element that contains P
2009  const Elem * e = locator(p);
2010 
2011  Number u = 0;
2012 
2013  if (e && this->get_dof_map().is_evaluable(*e, var))
2014  u = point_value(var, p, *e);
2015 
2016  // If I have an element containing p, then let's let everyone know
2017  processor_id_type lowest_owner =
2018  (e && (e->processor_id() == this->processor_id())) ?
2019  this->processor_id() : this->n_processors();
2020  this->comm().min(lowest_owner);
2021 
2022  // Everybody should get their value from a processor that was able
2023  // to compute it.
2024  // If nobody admits owning the point, we have a problem.
2025  if (lowest_owner != this->n_processors())
2026  this->comm().broadcast(u, lowest_owner);
2027  else
2028  libmesh_assert(!insist_on_success);
2029 
2030  return u;
2031 }
Number point_value(unsigned int var, const Point &p, const bool insist_on_success=true) const
Definition: system.C:1980
processor_id_type n_processors() const
MeshBase & mesh
uint8_t processor_id_type
Definition: id_types.h:99
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
void broadcast(T &data, const unsigned int root_id=0) const
bool verify(const T &r, const Communicator &comm=Communicator_World)
const Parallel::Communicator & comm() const
processor_id_type processor_id() const
Number libMesh::System::point_value ( unsigned int  var,
const Point p,
const Elem e 
) const
inherited
Returns
The value of the solution variable var at the physical point p contained in local Elem e

This version of point_value can be run in serial, but assumes e is in the local mesh partition or is algebraically ghosted.

Definition at line 2033 of file system.C.

References libMesh::FEInterface::compute_data(), libMesh::Elem::contains_point(), libMesh::System::current_solution(), libMesh::Elem::dim(), libMesh::System::get_dof_map(), libMesh::System::get_equation_systems(), and libMesh::FEInterface::inverse_map().

2034 {
2035  // Ensuring that the given point is really in the element is an
2036  // expensive assert, but as long as debugging is turned on we might
2037  // as well try to catch a particularly nasty potential error
2038  libmesh_assert (e.contains_point(p));
2039 
2040  // Get the dof map to get the proper indices for our computation
2041  const DofMap & dof_map = this->get_dof_map();
2042 
2043  // Make sure we can evaluate on this element.
2044  libmesh_assert (dof_map.is_evaluable(e, var));
2045 
2046  // Need dof_indices for phi[i][j]
2047  std::vector<dof_id_type> dof_indices;
2048 
2049  // Fill in the dof_indices for our element
2050  dof_map.dof_indices (&e, dof_indices, var);
2051 
2052  // Get the no of dofs associated with this point
2053  const unsigned int num_dofs = cast_int<unsigned int>
2054  (dof_indices.size());
2055 
2056  FEType fe_type = dof_map.variable_type(var);
2057 
2058  // Map the physical co-ordinates to the master co-ordinates using the inverse_map from fe_interface.h.
2059  Point coor = FEInterface::inverse_map(e.dim(), fe_type, &e, p);
2060 
2061  // get the shape function value via the FEInterface to also handle the case
2062  // of infinite elements correcly, the shape function is not fe->phi().
2063  FEComputeData fe_data(this->get_equation_systems(), coor);
2064  FEInterface::compute_data(e.dim(), fe_type, &e, fe_data);
2065 
2066  // Get ready to accumulate a value
2067  Number u = 0;
2068 
2069  for (unsigned int l=0; l<num_dofs; l++)
2070  {
2071  u += fe_data.shape[l]*this->current_solution (dof_indices[l]);
2072  }
2073 
2074  return u;
2075 }
const DofMap & get_dof_map() const
Definition: system.h:2030
static void compute_data(const unsigned int dim, const FEType &fe_t, const Elem *elem, FEComputeData &data)
Definition: fe_interface.C:794
static Point inverse_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: fe_interface.C:547
Number current_solution(const dof_id_type global_dof_number) const
Definition: system.C:192
const EquationSystems & get_equation_systems() const
Definition: system.h:698
Number libMesh::System::point_value ( unsigned int  var,
const Point p,
const Elem e 
) const
inherited

Calls the version of point_value() which takes a reference. This function exists only to prevent people from calling the version of point_value() that has a boolean third argument, which would result in unnecessary PointLocator calls.

Definition at line 2079 of file system.C.

References libMesh::System::point_value().

2080 {
2081  libmesh_assert(e);
2082  return this->point_value(var, p, *e);
2083 }
Number point_value(unsigned int var, const Point &p, const bool insist_on_success=true) const
Definition: system.C:1980
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::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::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::CheckpointIO::select_split_config(), 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::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::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(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

100  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
unsigned int rank() const
Definition: parallel.h:723
void libMesh::System::project_solution ( FunctionBase< Number > *  f,
FunctionBase< Gradient > *  g = libmesh_nullptr 
) const
inherited

Projects arbitrary functions onto the current solution. The function value f and its gradient g are user-provided cloneable functors. A gradient g is only required/used for projecting onto finite element spaces with continuous derivatives. If non-default Parameters are to be used, they can be provided in the parameters argument.

This method projects an arbitrary function onto the solution via L2 projections and nodal interpolations on each element.

Definition at line 810 of file system_projection.C.

Referenced by libMesh::System::system_type().

812 {
813  this->project_vector(*solution, f, g);
814 
815  solution->localize(*current_local_solution, _dof_map->get_send_list());
816 }
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
std::unique_ptr< NumericVector< Number > > solution
Definition: system.h:1509
std::unique_ptr< NumericVector< Number > > current_local_solution
Definition: system.h:1521
void project_vector(NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
void libMesh::System::project_solution ( FEMFunctionBase< Number > *  f,
FEMFunctionBase< Gradient > *  g = libmesh_nullptr 
) const
inherited

Projects arbitrary functions onto the current solution. The function value f and its gradient g are user-provided cloneable functors. A gradient g is only required/used for projecting onto finite element spaces with continuous derivatives. If non-default Parameters are to be used, they can be provided in the parameters argument.

This method projects an arbitrary function onto the solution via L2 projections and nodal interpolations on each element.

Definition at line 823 of file system_projection.C.

825 {
826  this->project_vector(*solution, f, g);
827 
828  solution->localize(*current_local_solution, _dof_map->get_send_list());
829 }
std::unique_ptr< DofMap > _dof_map
Definition: system.h:1865
std::unique_ptr< NumericVector< Number > > solution
Definition: system.h:1509
std::unique_ptr< NumericVector< Number > > current_local_solution
Definition: system.h:1521
void project_vector(NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
void libMesh::System::project_solution ( ValueFunctionPointer  fptr,
GradientFunctionPointer  gptr,
const Parameters parameters 
) const
inherited

This method projects an arbitrary function onto the solution via L2 projections and nodal interpolations on each element.

Definition at line 796 of file system_projection.C.

799 {
800  WrappedFunction<Number> f(*this, fptr, &parameters);
801  WrappedFunction<Gradient> g(*this, gptr, &parameters);
802  this->project_solution(&f, &g);
803 }
void project_solution(FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr) const
bool& libMesh::System::project_solution_on_reinit ( void  )
inlineinherited

Tells the System whether or not to project the solution vector onto new grids when the system is reinitialized. The solution will be projected unless project_solution_on_reinit() = false is called.

Definition at line 780 of file system.h.

References libMesh::System::_solution_projection, libMesh::System::add_adjoint_rhs(), libMesh::System::add_adjoint_solution(), libMesh::System::add_sensitivity_rhs(), libMesh::System::add_sensitivity_solution(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_weighted_sensitivity_adjoint_solution(), libMesh::System::add_weighted_sensitivity_solution(), libMesh::System::calculate_norm(), libMesh::FIRST, libMesh::System::get_adjoint_rhs(), libMesh::System::get_adjoint_solution(), libMesh::System::get_all_variable_numbers(), libMesh::System::get_sensitivity_rhs(), libMesh::System::get_sensitivity_solution(), libMesh::System::get_vector(), libMesh::System::get_weighted_sensitivity_adjoint_solution(), libMesh::System::get_weighted_sensitivity_solution(), libMesh::System::has_variable(), libMesh::System::have_vector(), libMesh::System::identify_variable_groups(), libMesh::LAGRANGE, libmesh_nullptr, libMesh::System::n_active_dofs(), libMesh::System::n_components(), libMesh::System::n_constrained_dofs(), libMesh::System::n_dofs(), libMesh::System::n_local_constrained_dofs(), libMesh::System::n_local_dofs(), libMesh::System::n_matrices(), libMesh::System::n_variable_groups(), libMesh::System::n_vars(), libMesh::System::n_vectors(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::System::read_serialized_data(), libMesh::Real, libMesh::System::request_vector(), libMesh::System::set_vector_as_adjoint(), libMesh::System::set_vector_preservation(), libMesh::System::variable(), libMesh::System::variable_group(), libMesh::System::variable_name(), libMesh::System::variable_number(), libMesh::System::variable_scalar_number(), libMesh::System::variable_type(), libMesh::System::vector_is_adjoint(), libMesh::System::vector_name(), and libMesh::System::vector_preservation().

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), and libMesh::MemorySolutionHistory::store().

781  { return _solution_projection; }
bool _solution_projection
Definition: system.h:1940
void libMesh::System::project_vector ( NumericVector< Number > &  new_vector,
FunctionBase< Number > *  f,
FunctionBase< Gradient > *  g = libmesh_nullptr,
int  is_adjoint = -1 
) const
inherited

Projects arbitrary functions onto a vector of degree of freedom values for the current system. The function value f and its gradient g are user-provided cloneable functors. A gradient g is only required/used for projecting onto finite element spaces with continuous derivatives. If non-default Parameters are to be used, they can be provided in the parameters argument.

Constrain the new vector using the requested adjoint rather than primal constraints if is_adjoint is non-negative.

This method projects an arbitrary function via L2 projections and nodal interpolations on each element.

Definition at line 851 of file system_projection.C.

References libmesh_nullptr.

Referenced by libMesh::System::hide_output(), libMesh::NewmarkSolver::project_initial_accel(), libMesh::SecondOrderUnsteadySolver::project_initial_rate(), libMesh::System::project_vector(), and libMesh::System::restrict_vectors().

855 {
856  LOG_SCOPE ("project_vector(FunctionBase)", "System");
857 
858  libmesh_assert(f);
859 
860  WrappedFunctor<Number> f_fem(*f);
861 
862  if (g)
863  {
864  WrappedFunctor<Gradient> g_fem(*g);
865 
866  this->project_vector(new_vector, &f_fem, &g_fem, is_adjoint);
867  }
868  else
869  this->project_vector(new_vector, &f_fem, libmesh_nullptr, is_adjoint);
870 }
const class libmesh_nullptr_t libmesh_nullptr
void project_vector(NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
void libMesh::System::project_vector ( NumericVector< Number > &  new_vector,
FEMFunctionBase< Number > *  f,
FEMFunctionBase< Gradient > *  g = libmesh_nullptr,
int  is_adjoint = -1 
) const
inherited

Projects arbitrary functions onto a vector of degree of freedom values for the current system. The function value f and its gradient g are user-provided cloneable functors. A gradient g is only required/used for projecting onto finite element spaces with continuous derivatives. If non-default Parameters are to be used, they can be provided in the parameters argument.

Constrain the new vector using the requested adjoint rather than primal constraints if is_adjoint is non-negative.

This method projects an arbitrary function via L2 projections and nodal interpolations on each element.

Definition at line 877 of file system_projection.C.

References libMesh::NumericVector< T >::close(), libMesh::FEMFunctionBase< Output >::component(), libmesh_nullptr, libMesh::n_processors(), n_vars, libMesh::Threads::parallel_for(), libMesh::FEMContext::pre_fe_reinit(), libMesh::processor_id(), libMesh::SCALAR, libMesh::DofMap::SCALAR_dof_indices(), and libMesh::NumericVector< T >::set().

881 {
882  LOG_SCOPE ("project_fem_vector()", "System");
883 
884  libmesh_assert (f);
885 
886  ConstElemRange active_local_range
887  (this->get_mesh().active_local_elements_begin(),
888  this->get_mesh().active_local_elements_end() );
889 
890  VectorSetAction<Number> setter(new_vector);
891 
892  const unsigned int n_variables = this->n_vars();
893 
894  std::vector<unsigned int> vars(n_variables);
895  for (unsigned int i=0; i != n_variables; ++i)
896  vars[i] = i;
897 
898  // Use a typedef to make the calling sequence for parallel_for() a bit more readable
899  typedef
900  GenericProjector<FEMFunctionWrapper<Number>, FEMFunctionWrapper<Gradient>,
901  Number, VectorSetAction<Number>> FEMProjector;
902 
903  FEMFunctionWrapper<Number> fw(*f);
904 
905  if (g)
906  {
907  FEMFunctionWrapper<Gradient> gw(*g);
908 
910  (active_local_range,
911  FEMProjector(*this, fw, &gw, setter, vars));
912  }
913  else
915  (active_local_range,
916  FEMProjector(*this, fw, libmesh_nullptr, setter, vars));
917 
918  // Also, load values into the SCALAR dofs
919  // Note: We assume that all SCALAR dofs are on the
920  // processor with highest ID
921  if (this->processor_id() == (this->n_processors()-1))
922  {
923  // FIXME: Do we want to first check for SCALAR vars before building this? [PB]
924  FEMContext context( *this );
925 
926  const DofMap & dof_map = this->get_dof_map();
927  for (unsigned int var=0; var<this->n_vars(); var++)
928  if (this->variable(var).type().family == SCALAR)
929  {
930  // FIXME: We reinit with an arbitrary element in case the user
931  // doesn't override FEMFunctionBase::component. Is there
932  // any use case we're missing? [PB]
933  Elem * el = const_cast<Elem *>(*(this->get_mesh().active_local_elements_begin()));
934  context.pre_fe_reinit(*this, el);
935 
936  std::vector<dof_id_type> SCALAR_indices;
937  dof_map.SCALAR_dof_indices (SCALAR_indices, var);
938  const unsigned int n_SCALAR_dofs =
939  cast_int<unsigned int>(SCALAR_indices.size());
940 
941  for (unsigned int i=0; i<n_SCALAR_dofs; i++)
942  {
943  const dof_id_type global_index = SCALAR_indices[i];
944  const unsigned int component_index =
945  this->variable_scalar_number(var,i);
946 
947  new_vector.set(global_index, f->component(context, component_index, Point(), this->time));
948  }
949  }
950  }
951 
952  new_vector.close();
953 
954 #ifdef LIBMESH_ENABLE_CONSTRAINTS
955  if (is_adjoint == -1)
956  this->get_dof_map().enforce_constraints_exactly(*this, &new_vector);
957  else if (is_adjoint >= 0)
959  is_adjoint);
960 #endif
961 }
FEFamily family
Definition: fe_type.h:204
const FEType & type() const
Definition: variable.h:119
void parallel_for(const Range &range, const Body &body)
Definition: threads_none.h:73
processor_id_type n_processors() const
const class libmesh_nullptr_t libmesh_nullptr
StoredRange< MeshBase::const_element_iterator, const Elem * > ConstElemRange
Definition: elem_range.h:34
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
const Variable & variable(unsigned int var) const
Definition: system.h:2114
virtual element_iterator active_local_elements_begin()=0
void enforce_constraints_exactly(const System &system, NumericVector< Number > *v=libmesh_nullptr, bool homogeneous=false) const
virtual void close()=0
unsigned int variable_scalar_number(const std::string &var, unsigned int component) const
Definition: system.h:2145
unsigned int n_vars() const
Definition: system.h:2086
virtual void set(const numeric_index_type i, const T value)=0
void enforce_adjoint_constraints_exactly(NumericVector< Number > &v, unsigned int q) const
uint8_t dof_id_type
Definition: id_types.h:64
processor_id_type processor_id() const
void libMesh::System::project_vector ( ValueFunctionPointer  fptr,
GradientFunctionPointer  gptr,
const Parameters parameters,
NumericVector< Number > &  new_vector,
int  is_adjoint = -1 
) const
inherited

Projects arbitrary functions onto a vector of degree of freedom values for the current system. The function value fptr and its gradient gptr are represented by function pointers. A gradient gptr is only required/used for projecting onto finite element spaces with continuous derivatives.

Constrain the new vector using the requested adjoint rather than primal constraints if is_adjoint is non-negative.

This method projects an arbitrary function via L2 projections and nodal interpolations on each element.

Definition at line 836 of file system_projection.C.

841 {
842  WrappedFunction<Number> f(*this, fptr, &parameters);
843  WrappedFunction<Gradient> g(*this, gptr, &parameters);
844  this->project_vector(new_vector, &f, &g, is_adjoint);
845 }
void project_vector(NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
void libMesh::System::project_vector ( NumericVector< Number > &  vector,
int  is_adjoint = -1 
) const
protectedinherited

Projects the vector defined on the old mesh onto the new mesh.

Constrain the new vector using the requested adjoint rather than primal constraints if is_adjoint is non-negative.

Definition at line 202 of file system_projection.C.

References libMesh::NumericVector< T >::build(), libMesh::NumericVector< T >::clear(), libMesh::NumericVector< T >::clone(), libMesh::NumericVector< T >::close(), libMesh::NumericVector< T >::get(), libMesh::GHOSTED, libMesh::NumericVector< T >::init(), libmesh_nullptr, libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::localize(), libMesh::n_processors(), n_vars, libMesh::PARALLEL, libMesh::Threads::parallel_for(), libMesh::Threads::parallel_reduce(), libMesh::processor_id(), libMesh::System::project_vector(), libMesh::SCALAR, libMesh::DofMap::SCALAR_dof_indices(), libMesh::BuildProjectionList::send_list, libMesh::SERIAL, libMesh::NumericVector< T >::set(), libMesh::NumericVector< T >::size(), libMesh::NumericVector< T >::type(), and libMesh::BuildProjectionList::unique().

204 {
205  // Create a copy of the vector, which currently
206  // contains the old data.
207  std::unique_ptr<NumericVector<Number>>
208  old_vector (vector.clone());
209 
210  // Project the old vector to the new vector
211  this->project_vector (*old_vector, vector, is_adjoint);
212 }
virtual std::unique_ptr< NumericVector< T > > clone() const =0
void project_vector(NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=libmesh_nullptr, int is_adjoint=-1) const
void libMesh::System::project_vector ( const NumericVector< Number > &  ,
NumericVector< Number > &  ,
int  is_adjoint = -1 
) const
protectedinherited

Projects the vector defined on the old mesh onto the new mesh. The original vector is unchanged and the new vector is passed through the second argument.

Constrain the new vector using the requested adjoint rather than primal constraints if is_adjoint is non-negative.

void libMesh::System::projection_matrix ( SparseMatrix< Number > &  proj_mat) const
inherited

This method creates a projection matrix which corresponds to the operation of project_vector between old and new solution spaces.

Heterogeneous Dirichlet boundary conditions are not taken into account here; if this matrix is used for prolongation (mesh refinement) on a side with a heterogeneous BC, the newly created degrees of freedom on that side will still match the coarse grid approximation of the BC, not the fine grid approximation.

This method creates a projection matrix which corresponds to the operation of project_vector between old and new solution spaces.

Definition at line 729 of file system_projection.C.

References libMesh::n_processors(), n_vars, libMesh::Threads::parallel_for(), libMesh::processor_id(), libMesh::SCALAR, libMesh::DofMap::SCALAR_dof_indices(), and libMesh::SparseMatrix< T >::set().

Referenced by libMesh::System::hide_output().

730 {
731  LOG_SCOPE ("projection_matrix()", "System");
732 
733  const unsigned int n_variables = this->n_vars();
734 
735  if (n_variables)
736  {
737  ConstElemRange active_local_elem_range
738  (this->get_mesh().active_local_elements_begin(),
739  this->get_mesh().active_local_elements_end());
740 
741  std::vector<unsigned int> vars(n_variables);
742  for (unsigned int i=0; i != n_variables; ++i)
743  vars[i] = i;
744 
745  // Use a typedef to make the calling sequence for parallel_for() a bit more readable
746  typedef OldSolutionCoefs<Real, &FEMContext::point_value> OldSolutionValueCoefs;
747  typedef OldSolutionCoefs<RealGradient, &FEMContext::point_gradient> OldSolutionGradientCoefs;
748 
749  typedef
750  GenericProjector<OldSolutionValueCoefs,
751  OldSolutionGradientCoefs,
752  DynamicSparseNumberArray<Real,dof_id_type>,
753  MatrixFillAction<Real, Number> > ProjMatFiller;
754 
755  OldSolutionValueCoefs f(*this);
756  OldSolutionGradientCoefs g(*this);
757  MatrixFillAction<Real, Number> setter(proj_mat);
758 
759  Threads::parallel_for (active_local_elem_range,
760  ProjMatFiller(*this, f, &g, setter, vars));
761 
762  // Set the SCALAR dof transfer entries too.
763  // Note: We assume that all SCALAR dofs are on the
764  // processor with highest ID
765  if (this->processor_id() == (this->n_processors()-1))
766  {
767  const DofMap & dof_map = this->get_dof_map();
768  for (unsigned int var=0; var<this->n_vars(); var++)
769  if (this->variable(var).type().family == SCALAR)
770  {
771  // We can just map SCALAR dofs directly across
772  std::vector<dof_id_type> new_SCALAR_indices, old_SCALAR_indices;
773  dof_map.SCALAR_dof_indices (new_SCALAR_indices, var, false);
774  dof_map.SCALAR_dof_indices (old_SCALAR_indices, var, true);
775  const unsigned int new_n_dofs =
776  cast_int<unsigned int>(new_SCALAR_indices.size());
777 
778  for (unsigned int i=0; i<new_n_dofs; i++)
779  {
780  proj_mat.set( new_SCALAR_indices[i],
781  old_SCALAR_indices[i], 1);
782  }
783  }
784  }
785  }
786 }
FEFamily family
Definition: fe_type.h:204
const FEType & type() const
Definition: variable.h:119
void parallel_for(const Range &range, const Body &body)
Definition: threads_none.h:73
processor_id_type n_processors() const
StoredRange< MeshBase::const_element_iterator, const Elem * > ConstElemRange
Definition: elem_range.h:34
virtual void set(const numeric_index_type i, const numeric_index_type j, const T value)=0
const MeshBase & get_mesh() const
Definition: system.h:2014
const DofMap & get_dof_map() const
Definition: system.h:2030
const Variable & variable(unsigned int var) const
Definition: system.h:2114
unsigned int n_vars() const
Definition: system.h:2086
processor_id_type processor_id() const
void libMesh::System::prolong_vectors ( )
virtualinherited

Prolong vectors after the mesh has refined

Definition at line 378 of file system.C.

References libMesh::System::restrict_vectors().

Referenced by libMesh::System::read_parallel_data(), and libMesh::EquationSystems::reinit_solutions().

379 {
380 #ifdef LIBMESH_ENABLE_AMR
381  // Currently project_vector handles both restriction and prolongation
382  this->restrict_vectors();
383 #endif
384 }
virtual void restrict_vectors()
Definition: system.C:322
void libMesh::ImplicitSystem::qoi_parameter_hessian ( const QoISet qoi_indices,
const ParameterVector parameters,
SensitivityData hessian 
)
virtualinherited