doxygen/libmesh/system_8h_source.html

// The libMesh Finite Element Library.

// Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner


// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Lesser General Public

// License as published by the Free Software Foundation; either

// version 2.1 of the License, or (at your option) any later version.


// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

// Lesser General Public License for more details.


// You should have received a copy of the GNU Lesser General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


#ifndef LIBMESH_SYSTEM_H

#define LIBMESH_SYSTEM_H


// Local Includes

#include "libmesh/elem_range.h"

#include "libmesh/enum_subset_solve_mode.h" // SUBSET_ZERO

#include "libmesh/enum_parallel_type.h" // PARALLEL

#include "libmesh/fem_function_base.h"

#include "libmesh/libmesh_common.h"

#include "libmesh/parallel_object.h"

#include "libmesh/parameters.h"

#include "libmesh/qoi_set.h"

#include "libmesh/reference_counted_object.h"

#include "libmesh/tensor_value.h" // For point_hessian

#include "libmesh/enum_matrix_build_type.h" // AUTOMATIC


// C++ includes

#include <cstddef>

#include <set>

#include <string>

#include <string_view>

#include <vector>

#include <memory>

#include <optional>


// This define may be useful in --disable-optional builds when it is

// possible that libmesh will not have any solvers available.

#if defined(LIBMESH_HAVE_PETSC) || \

  defined(LIBMESH_HAVE_EIGEN)   || \

  defined(LIBMESH_HAVE_LASPACK) || \

  defined(LIBMESH_TRILINOS_HAVE_AZTECOO)

#define LIBMESH_HAVE_SOLVER 1

#endif


namespace libMesh

{


// Forward Declarations

class System;

class EquationSystems;

class MeshBase;

class Xdr;

class DofMap;

template <typename Output> class FunctionBase;

class ParameterVector;

class Point;

class SensitivityData;

class Matrix;

template <typename T> class NumericVector;

template <typename T> class SparseMatrix;

template <typename T> class VectorValue;

typedef VectorValue<Number> NumberVectorValue;

typedef NumberVectorValue Gradient;

class SystemSubset;

class FEType;

class SystemNorm;

enum FEMNormType : int;

class Variable;

class VariableGroup;


class System : public ReferenceCountedObject<System>,

               public ParallelObject

{

public:


  System (EquationSystems & es,

          const std::string & name,

          const unsigned int number);


  System (const System &) = delete;

  System & operator= (const System &) = delete;

  System (System &&) = default;

  System & operator= (System &&) = delete;

  virtual ~System ();


  class Initialization

  {

  public:

    virtual ~Initialization () = default;


    virtual void initialize () = 0;

  };


  class Assembly

  {

  public:

    virtual ~Assembly () = default;


    virtual void assemble () = 0;

  };


  class Constraint

  {

  public:

    virtual ~Constraint () = default;


    virtual void constrain () = 0;

  };


  class QOI

  {

  public:

    virtual ~QOI () = default;


    virtual void qoi (const QoISet & qoi_indices) = 0;

  };


  class QOIDerivative

  {

  public:

    virtual ~QOIDerivative () = default;


    virtual void qoi_derivative (const QoISet & qoi_indices,

                                 bool include_liftfunc,

                                 bool apply_constraints) = 0;

  };


  typedef System sys_type;


  sys_type & system () { return *this; }


  virtual void clear ();


  void init ();


  virtual void reinit ();


  virtual void reinit_constraints ();


  virtual void reinit_mesh();


  bool is_initialized() const;


  virtual void update ();


  virtual void assemble ();


  virtual void assemble_qoi (const QoISet & qoi_indices = QoISet());


  virtual void assemble_qoi_derivative (const QoISet & qoi_indices = QoISet(),

                                        bool include_liftfunc = true,

                                        bool apply_constraints = true);


  virtual void assemble_residual_derivatives (const ParameterVector & parameters);


  virtual void restrict_solve_to (const SystemSubset * subset,

                                  const SubsetSolveMode subset_solve_mode=SUBSET_ZERO);


  virtual void solve () {}


  virtual std::pair<unsigned int, Real>

  sensitivity_solve (const ParameterVector & parameters);


  virtual std::pair<unsigned int, Real>

  weighted_sensitivity_solve (const ParameterVector & parameters,

                              const ParameterVector & weights);


  virtual std::pair<unsigned int, Real>

  adjoint_solve (const QoISet & qoi_indices = QoISet());


  virtual std::pair<unsigned int, Real>

  weighted_sensitivity_adjoint_solve (const ParameterVector & parameters,

                                      const ParameterVector & weights,

                                      const QoISet & qoi_indices = QoISet());


  bool is_adjoint_already_solved() const

  { return adjoint_already_solved;}


  void set_adjoint_already_solved(bool setting)

  { adjoint_already_solved = setting;}


  virtual void qoi_parameter_sensitivity (const QoISet & qoi_indices,

                                          const ParameterVector & parameters,

                                          SensitivityData & sensitivities);


  virtual void adjoint_qoi_parameter_sensitivity (const QoISet & qoi_indices,

                                                  const ParameterVector & parameters,

                                                  SensitivityData & sensitivities);


  virtual void forward_qoi_parameter_sensitivity (const QoISet & qoi_indices,

                                                  const ParameterVector & parameters,

                                                  SensitivityData & sensitivities);


  virtual void qoi_parameter_hessian(const QoISet & qoi_indices,

                                     const ParameterVector & parameters,

                                     SensitivityData & hessian);


  virtual void qoi_parameter_hessian_vector_product(const QoISet & qoi_indices,

                                                    const ParameterVector & parameters,

                                                    const ParameterVector & vector,

                                                    SensitivityData & product);


  virtual bool compare (const System & other_system,

                        const Real threshold,

                        const bool verbose) const;


  const std::string & name () const;


  virtual std::string system_type () const { return "Basic"; }


  void project_solution (FunctionBase<Number> * f,

                         FunctionBase<Gradient> * g = nullptr,

                         std::optional<ConstElemRange> active_local_range = std::nullopt,

                         std::optional<std::vector<unsigned int>> variable_numbers = std::nullopt) const;


  void project_solution (FEMFunctionBase<Number> * f,

                         FEMFunctionBase<Gradient> * g = nullptr,

                         std::optional<ConstElemRange> active_local_range = std::nullopt,

                         std::optional<std::vector<unsigned int>> variable_numbers = std::nullopt) const;


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

  void project_solution (ValueFunctionPointer fptr,

                         GradientFunctionPointer gptr,

                         const Parameters & parameters,

                         std::optional<ConstElemRange> active_local_range = std::nullopt,

                         std::optional<std::vector<unsigned int>> variable_numbers = std::nullopt) const;


  void project_vector (NumericVector<Number> & new_vector,

                       FunctionBase<Number> * f,

                       FunctionBase<Gradient> * g = nullptr,

                       int is_adjoint = -1,

                       std::optional<ConstElemRange> active_local_range = std::nullopt,

                       std::optional<std::vector<unsigned int>> variable_numbers = std::nullopt) const;


  void project_vector (NumericVector<Number> & new_vector,

                       FEMFunctionBase<Number> * f,

                       FEMFunctionBase<Gradient> * g = nullptr,

                       int is_adjoint = -1,

                       std::optional<ConstElemRange> active_local_range = std::nullopt,

                       std::optional<std::vector<unsigned int>> variable_numbers = std::nullopt) const;


  void project_vector (ValueFunctionPointer fptr,

                       GradientFunctionPointer gptr,

                       const Parameters & parameters,

                       NumericVector<Number> & new_vector,

                       int is_adjoint = -1,

                       std::optional<ConstElemRange> active_local_range = std::nullopt,

                       std::optional<std::vector<unsigned int>> variable_numbers = std::nullopt) const;


  void boundary_project_solution (const std::set<boundary_id_type> & b,

                                  const std::vector<unsigned int> & variables,

                                  FunctionBase<Number> * f,

                                  FunctionBase<Gradient> * g = nullptr,

                                  std::optional<ConstElemRange> active_local_range = std::nullopt);


  void boundary_project_solution (const std::set<boundary_id_type> & b,

                                  const std::vector<unsigned int> & variables,

                                  ValueFunctionPointer fptr,

                                  GradientFunctionPointer gptr,

                                  const Parameters & parameters,

                                  std::optional<ConstElemRange> active_local_range = std::nullopt);


  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 = nullptr,

                                int is_adjoint = -1,

                                std::optional<ConstElemRange> active_local_range = std::nullopt) 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,

                                std::optional<ConstElemRange> active_local_range = std::nullopt) 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 MeshBase & get_mesh() const;


  MeshBase & get_mesh();


  const DofMap & get_dof_map() const;


  DofMap & get_dof_map();


  const EquationSystems & get_equation_systems() const { return _equation_systems; }


  EquationSystems & get_equation_systems() { return _equation_systems; }


  bool active () const;


  void activate ();


  void deactivate ();


  void set_basic_system_only ();


  typedef std::map<std::string, std::unique_ptr<NumericVector<Number>>, std::less<>>::iterator       vectors_iterator;

  typedef std::map<std::string, std::unique_ptr<NumericVector<Number>>, std::less<>>::const_iterator const_vectors_iterator;


  vectors_iterator vectors_begin ();


  const_vectors_iterator vectors_begin () const;


  vectors_iterator vectors_end ();


  const_vectors_iterator vectors_end () const;


  typedef std::map<std::string, std::unique_ptr<SparseMatrix<Number>>, std::less<>>::iterator        matrices_iterator;

  typedef std::map<std::string, std::unique_ptr<SparseMatrix<Number>>, std::less<>>::const_iterator  const_matrices_iterator;


  matrices_iterator matrices_begin ();


  const_matrices_iterator matrices_begin () const;


  matrices_iterator matrices_end ();


  const_matrices_iterator matrices_end () const;


  NumericVector<Number> & add_vector (std::string_view vec_name,

                                      const bool projections=true,

                                      const ParallelType type = PARALLEL);


  void remove_vector(std::string_view vec_name);


  bool & project_solution_on_reinit (void)

  { return _solution_projection; }


  bool have_vector (std::string_view vec_name) const;


  const NumericVector<Number> * request_vector (std::string_view vec_name) const;


  NumericVector<Number> * request_vector (std::string_view 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 (std::string_view vec_name) const;


  NumericVector<Number> & get_vector (std::string_view 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 (std::string_view vec_name) const;


  void set_vector_preservation (const std::string & vec_name, bool preserve);


  bool vector_preservation (std::string_view 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_matrices () 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 (std::string_view var,

                             const FEType & type,

                             const std::set<subdomain_id_type> * const active_subdomains = nullptr);


  unsigned int add_variable (std::string_view var,

                             const Order order = FIRST,

                             const FEFamily = LAGRANGE,

                             const std::set<subdomain_id_type> * const active_subdomains = nullptr,

                             const bool p_refinement = true);


  unsigned int add_variables (const std::vector<std::string> & vars,

                              const FEType & type,

                              const std::set<subdomain_id_type> * const active_subdomains = nullptr);


  unsigned int add_variable_array (const std::vector<std::string> & vars,

                                   const FEType & type,

                                   const std::set<subdomain_id_type> * const active_subdomains = 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 = nullptr,

                              const bool p_refinement = true);


  const Variable & variable (unsigned int var) const;


  const VariableGroup & variable_group (unsigned int vg) const;


  bool has_variable(std::string_view var) const;


  const std::string & variable_name(const unsigned int i) const;


  unsigned int variable_number (std::string_view var) const;


  void get_all_variable_numbers(std::vector<unsigned int> & all_variable_numbers) const;


  unsigned int variable_scalar_number (std::string_view var,

                                       unsigned int component) const;


  unsigned int variable_scalar_number (unsigned int var_num,

                                       unsigned int component) const;


  const FEType & variable_type (const unsigned int i) const;


  const FEType & variable_type (std::string_view 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=nullptr) const;


  Real calculate_norm(const NumericVector<Number> & v,

                      const SystemNorm & norm,

                      std::set<unsigned int> * skip_dimensions=nullptr) const;


  void read_header (Xdr & io,

                    std::string_view version,

                    const bool read_header=true,

                    const bool read_additional_data=true,

                    const bool read_legacy_format=false);


  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)

  { read_serialized_data<Number>(io, read_additional_data); }


  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

  { return read_serialized_vectors<Number>(io, vectors); }


  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)

  { read_parallel_data<Number>(io, read_additional_data); }


  void write_header (Xdr & io,

                     std::string_view 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);


  bool has_constraint_object () const;


  Constraint& get_constraint_object ();


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


  Parameters parameters;


  bool assemble_before_solve;


  virtual void disable_cache ();


  bool use_fixed_solution;


  int extra_quadrature_order;


  //--------------------------------------------------

  // The solution and solution access members


  Number current_solution (const dof_id_type global_dof_number) const;


  std::unique_ptr<NumericVector<Number>> solution;


  std::unique_ptr<NumericVector<Number>> current_local_solution;


  Real time;


  unsigned int n_qois() const;


public:


  void init_qois(unsigned int n_qois);


  void set_qoi(unsigned int qoi_index, Number qoi_value);

  Number get_qoi_value(unsigned int qoi_index) const;


  void set_qoi(std::vector<Number> new_qoi);


  std::vector<Number> get_qoi_values() const;


  void set_qoi_error_estimate(unsigned int qoi_index, Number qoi_error_estimate);

  Number get_qoi_error_estimate_value(unsigned int qoi_index) const;


  Number point_value(unsigned int var, const Point & p,

                     const bool insist_on_success = true,

                     const NumericVector<Number> * sol = nullptr) const;


  Number point_value(unsigned int var, const Point & p, const Elem & e,

                     const NumericVector<Number> * sol = nullptr) const;


  Number point_value(unsigned int var, const Point & p, const Elem * e) const;


  Number point_value(unsigned int var, const Point & p, const NumericVector<Number> * sol) const;


  Gradient point_gradient(unsigned int var, const Point & p,

                          const bool insist_on_success = true,

                          const NumericVector<Number> * sol = nullptr) const;


  Gradient point_gradient(unsigned int var, const Point & p, const Elem & e,

                          const NumericVector<Number> * sol = nullptr) const;


  Gradient point_gradient(unsigned int var, const Point & p, const Elem * e) const;


  Gradient point_gradient(unsigned int var, const Point & p, const NumericVector<Number> * sol) const;


  Tensor point_hessian(unsigned int var, const Point & p,

                       const bool insist_on_success = true,

                       const NumericVector<Number> * sol = nullptr) const;


  Tensor point_hessian(unsigned int var, const Point & p, const Elem & e,

                       const NumericVector<Number> * sol = nullptr) const;


  Tensor point_hessian(unsigned int var, const Point & p, const Elem * e) const;


  Tensor point_hessian(unsigned int var, const Point & p, const NumericVector<Number> * sol) 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 get_project_with_constraints()

  {

    return project_with_constraints;

  }


  void set_project_with_constraints(bool _project_with_constraints)

  {

    project_with_constraints = _project_with_constraints;

  }


  bool & hide_output() { return _hide_output; }


#ifdef LIBMESH_HAVE_METAPHYSICL

  void projection_matrix (SparseMatrix<Number> & proj_mat) const;

#endif // LIBMESH_HAVE_METAPHYSICL


  SparseMatrix<Number> & add_matrix (std::string_view mat_name,

                                     ParallelType type = PARALLEL,

                                     MatrixBuildType mat_build_type = MatrixBuildType::AUTOMATIC);


  template <template <typename> class>

  SparseMatrix<Number> & add_matrix (std::string_view mat_name, ParallelType = PARALLEL);


  SparseMatrix<Number> & add_matrix (std::string_view mat_name,

                                     std::unique_ptr<SparseMatrix<Number>> matrix,

                                     ParallelType type = PARALLEL);


  void remove_matrix(std::string_view mat_name);


  inline bool have_matrix (std::string_view mat_name) const { return _matrices.count(mat_name); }


  const SparseMatrix<Number> * request_matrix (std::string_view mat_name) const;


  SparseMatrix<Number> * request_matrix (std::string_view mat_name);


  const SparseMatrix<Number> & get_matrix (std::string_view mat_name) const;


  SparseMatrix<Number> & get_matrix (std::string_view mat_name);


  void prefer_hash_table_matrix_assembly(bool preference);


  void prefix_with_name(bool value) { _prefix_with_name = value; }


  [[nodiscard]] bool prefix_with_name() const { return _prefix_with_name; }


  std::string prefix() const { return this->name() + "_"; }


   virtual void create_static_condensation();


   bool has_static_condensation() const;


  /*

   * If we have e.g. a element space constrained by spline values, we

   * can directly project functions only on the constrained basis; to

   * get consistent constraining values we have to solve for them.

   *

   * Constrain the new vector using the requested adjoint rather than

   * primal constraints if is_adjoint is non-negative.

   */

  void solve_for_unconstrained_dofs (NumericVector<Number> &,

                                     int is_adjoint = -1) const;


protected:


  virtual void init_data ();


  virtual void add_matrices() {}


  virtual void init_matrices ();


  bool can_add_matrices() const { return !_matrices_initialized; }


  void project_vector (NumericVector<Number> &,

                       int is_adjoint = -1,

                       std::optional<ConstElemRange> active_local_range = std::nullopt,

                       std::optional<std::vector<unsigned int>> variable_numbers = std::nullopt) const;


  void project_vector (const NumericVector<Number> &,

                       NumericVector<Number> &,

                       int is_adjoint = -1,

                       std::optional<ConstElemRange> active_local_range = std::nullopt,

                       std::optional<std::vector<unsigned int>> variable_numbers = std::nullopt) const;


  virtual bool condense_constrained_dofs() const { return false; }


private:

  void late_matrix_init(SparseMatrix<Number> & mat,

                        ParallelType type);


  Real discrete_var_norm (const NumericVector<Number> & v,

                          unsigned int var,

                          FEMNormType norm_type) const;


  template <typename iterator_type, typename InValType>

  std::size_t read_serialized_blocked_dof_objects (const dof_id_type n_objects,

                                                   const iterator_type begin,

                                                   const iterator_type end,

                                                   const InValType dummy,

                                                   Xdr & io,

                                                   const std::vector<NumericVector<Number> *> & vecs,

                                                   const unsigned int var_to_read=libMesh::invalid_uint) const;


  unsigned int read_SCALAR_dofs (const unsigned int var,

                                 Xdr & io,

                                 NumericVector<Number> * vec) const;


  template <typename InValType>

  numeric_index_type read_serialized_vector (Xdr & io,

                                             NumericVector<Number> * vec);


  numeric_index_type read_serialized_vector (Xdr & io,

                                             NumericVector<Number> & vec)

  { return read_serialized_vector<Number>(io, &vec); }


  template <typename iterator_type>

  std::size_t write_serialized_blocked_dof_objects (const std::vector<const NumericVector<Number> *> & vecs,

                                                    const dof_id_type n_objects,

                                                    const iterator_type begin,

                                                    const iterator_type end,

                                                    Xdr & io,

                                                    const unsigned int var_to_write=libMesh::invalid_uint) const;


  unsigned int write_SCALAR_dofs (const NumericVector<Number> & vec,

                                  const unsigned int var,

                                  Xdr & io) const;


  dof_id_type write_serialized_vector (Xdr & io,

                                       const NumericVector<Number> & vec) const;


  void (* _init_system_function) (EquationSystems & es,

                                  const std::string & name);


  Initialization * _init_system_object;


  void (* _assemble_system_function) (EquationSystems & es,

                                      const std::string & name);


  Assembly * _assemble_system_object;


  void (* _constrain_system_function) (EquationSystems & es,

                                       const std::string & name);


  Constraint * _constrain_system_object;


  void (* _qoi_evaluate_function) (EquationSystems & es,

                                   const std::string & name,

                                   const QoISet & qoi_indices);


  QOI * _qoi_evaluate_object;


  void (* _qoi_evaluate_derivative_function) (EquationSystems & es,

                                              const std::string & name,

                                              const QoISet & qoi_indices,

                                              bool include_liftfunc,

                                              bool apply_constraints);


  QOIDerivative * _qoi_evaluate_derivative_object;


  std::unique_ptr<DofMap> _dof_map;


  EquationSystems & _equation_systems;


  MeshBase & _mesh;


  const std::string _sys_name;


  const unsigned int _sys_number;


  bool _active;


  std::map<std::string, std::unique_ptr<NumericVector<Number>>, std::less<>> _vectors;


  std::map<std::string, bool, std::less<>> _vector_projections;


  std::map<std::string, int, std::less<>> _vector_is_adjoint;


  std::map<std::string, std::unique_ptr<SparseMatrix<Number>>, std::less<>> _matrices;


  std::map<std::string, ParallelType, std::less<>> _matrix_types;


  bool _matrices_initialized;


  bool _solution_projection;


  bool _basic_system_only;


  bool _is_initialized;


  unsigned int _additional_data_written;


  std::vector<unsigned int> _written_var_indices;


  bool adjoint_already_solved;


  bool _hide_output;


  bool project_with_constraints;


  bool _prefer_hash_table_matrix_assembly;


  bool _require_sparsity_pattern;


  bool _prefix_with_name;


  std::vector<Number> _qoi;


  std::vector<Number> _qoi_error_estimates;

};


// ------------------------------------------------------------

// System inline methods

inline


const std::string & System::name() const

{

  return _sys_name;

}


inline


unsigned int System::number() const

{

  return _sys_number;

}


inline


const MeshBase & System::get_mesh() const

{

  return _mesh;

}


inline


MeshBase & System::get_mesh()

{

  return _mesh;

}


inline


const DofMap & System::get_dof_map() const

{

  return *_dof_map;

}


inline


DofMap & System::get_dof_map()

{

  return *_dof_map;

}


inline


bool System::active() const

{

  return _active;

}


inline


void System::activate ()

{

  _active = true;

}


inline


void System::deactivate ()

{

  _active = false;

}


inline


bool System::is_initialized () const

{

  return _is_initialized;

}


inline


void System::set_basic_system_only ()

{

  _basic_system_only = true;

}


inline

unsigned int


System::variable_scalar_number (std::string_view var,

                                unsigned int component) const

{

  return variable_scalar_number(this->variable_number(var), component);

}


inline


dof_id_type System::n_active_dofs() const

{

  return this->n_dofs() - this->n_constrained_dofs();

}


inline


bool System::have_vector (std::string_view vec_name) const

{

  return (_vectors.count(vec_name));

}


inline


unsigned int System::n_vectors () const

{

  return cast_int<unsigned int>(_vectors.size());

}


inline


System::vectors_iterator System::vectors_begin ()

{

  return _vectors.begin();

}


inline


System::const_vectors_iterator System::vectors_begin () const

{

  return _vectors.begin();

}


inline


System::vectors_iterator System::vectors_end ()

{

  return _vectors.end();

}


inline


System::const_vectors_iterator System::vectors_end () const

{

  return _vectors.end();

}


inline


System::matrices_iterator System::matrices_begin ()

{

  return _matrices.begin();

}


inline


System::const_matrices_iterator System::matrices_begin () const

{

  return _matrices.begin();

}


inline


System::matrices_iterator System::matrices_end ()

{

  return _matrices.end();

}


inline


System::const_matrices_iterator System::matrices_end () const

{

  return _matrices.end();

}


inline


void System::assemble_residual_derivatives (const ParameterVector &)

{

  libmesh_not_implemented();

}


inline

void System::disable_cache () { assemble_before_solve = true; }


inline


unsigned int System::n_qois() const

{

  libmesh_assert_equal_to(this->_qoi.size(), this->_qoi_error_estimates.size());


  return cast_int<unsigned int>(this->_qoi.size());

}


inline

std::pair<unsigned int, Real>


System::sensitivity_solve (const ParameterVector &)

{

  libmesh_not_implemented();

}


inline

std::pair<unsigned int, Real>


System::weighted_sensitivity_solve (const ParameterVector &,

                                    const ParameterVector &)

{

  libmesh_not_implemented();

}


inline

std::pair<unsigned int, Real>


System::adjoint_solve (const QoISet &)

{

  libmesh_not_implemented();

}


inline

std::pair<unsigned int, Real>


System::weighted_sensitivity_adjoint_solve (const ParameterVector &,

                                            const ParameterVector &,

                                            const QoISet &)

{

  libmesh_not_implemented();

}


inline

void


System::adjoint_qoi_parameter_sensitivity (const QoISet &,

                                           const ParameterVector &,

                                           SensitivityData &)

{

  libmesh_not_implemented();

}


inline

void


System::forward_qoi_parameter_sensitivity (const QoISet &,

                                           const ParameterVector &,

                                           SensitivityData &)

{

  libmesh_not_implemented();

}


inline

void


System::qoi_parameter_hessian(const QoISet &,

                              const ParameterVector &,

                              SensitivityData &)

{

  libmesh_not_implemented();

}


inline

void


System::qoi_parameter_hessian_vector_product(const QoISet &,

                                             const ParameterVector &,

                                             const ParameterVector &,

                                             SensitivityData &)

{

  libmesh_not_implemented();

}


inline


unsigned int System::n_matrices () const

{

  return cast_int<unsigned int>(_matrices.size());

}


template <template <typename> class MatrixType>

inline

SparseMatrix<Number> &


System::add_matrix (std::string_view mat_name,

                    const ParallelType type)

{

  // Return the matrix if it is already there.

  auto it = this->_matrices.find(mat_name);

  if (it != this->_matrices.end())

    return *it->second;


  // Otherwise build the matrix to return.

  auto pr = _matrices.emplace(mat_name, std::make_unique<MatrixType<Number>>(this->comm()));

  _matrix_types.emplace(mat_name, type);


  SparseMatrix<Number> & mat = *(pr.first->second);


  // Initialize it first if we've already initialized the others.

  this->late_matrix_init(mat, type);


  return mat;

}


inline void


System::prefer_hash_table_matrix_assembly(const bool preference)

{

  libmesh_error_msg_if(

      _matrices_initialized,

      "System::prefer_hash_table_matrix_assembly() should be called before matrices are initialized");

  _prefer_hash_table_matrix_assembly = preference;

}


} // namespace libMesh


#endif // LIBMESH_SYSTEM_H

int
void ErrorVector unsigned int
Definition adjoints_ex3.C:360

libMesh::DofMap
This class handles the numbering of degrees of freedom on a mesh.
Definition dof_map.h:181

libMesh::Elem
This is the base class from which all geometric element types are derived.
Definition elem.h:96

libMesh::EquationSystems
This is the EquationSystems class.
Definition equation_systems.h:72

libMesh::FEMFunctionBase
FEMFunctionBase is a base class from which users can derive in order to define "function-like" object...
Definition fem_function_base.h:47

libMesh::FEType
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition fe_type.h:197

libMesh::FunctionBase
Base class for functors that can be evaluated at a point and (optionally) time.
Definition function_base.h:64

libMesh::MeshBase
This is the MeshBase class.
Definition mesh_base.h:81

libMesh::NumericVector
Provides a uniform interface to vector storage schemes for different linear algebra libraries.
Definition numeric_vector.h:70

libMesh::ParallelObject
An object whose state is distributed along a set of processors.
Definition parallel_object.h:59

libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
Definition parallel_object.h:97

libMesh::ParameterVector
Data structure for specifying which Parameters should be independent variables in a parameter sensiti...
Definition parameter_vector.h:45

libMesh::Parameters
This class provides the ability to map between arbitrary, user-defined strings and several data types...
Definition parameters.h:75

libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition point.h:40

libMesh::QoISet
Data structure for specifying which Quantities of Interest should be calculated in an adjoint or a pa...
Definition qoi_set.h:46

libMesh::ReferenceCountedObject
This class implements reference counting.
Definition reference_counted_object.h:66

libMesh::ReferenceCounter::n_objects
static unsigned int n_objects()
Prints the number of outstanding (created, but not yet destroyed) objects.
Definition reference_counter.h:85

libMesh::SensitivityData
Data structure for holding completed parameter sensitivity calculations.
Definition sensitivity_data.h:47

libMesh::SparseMatrix
Generic sparse matrix.
Definition sparse_matrix.h:71

libMesh::SystemNorm
This class defines a norm/seminorm to be applied to a NumericVector which contains coefficients in a ...
Definition system_norm.h:50

libMesh::SystemSubset
This is a base class for classes which represent subsets of the dofs of a System.
Definition system_subset.h:43

libMesh::System::Assembly
Abstract base class to be used for system assembly.
Definition system.h:158

libMesh::System::Assembly::assemble
virtual void assemble()=0
Assembly function.

libMesh::System::Assembly::~Assembly
virtual ~Assembly()=default
Destructor.

libMesh::System::Constraint
Abstract base class to be used for system constraints.
Definition system.h:182

libMesh::System::Constraint::~Constraint
virtual ~Constraint()=default
Destructor.

libMesh::System::Constraint::constrain
virtual void constrain()=0
Constraint function.

libMesh::System::Initialization
Abstract base class to be used for system initialization.
Definition system.h:134

libMesh::System::Initialization::~Initialization
virtual ~Initialization()=default
Destructor.

libMesh::System::Initialization::initialize
virtual void initialize()=0
Initialization function.

libMesh::System::QOIDerivative
Abstract base class to be used for derivatives of quantities of interest.
Definition system.h:230

libMesh::System::QOIDerivative::qoi_derivative
virtual void qoi_derivative(const QoISet &qoi_indices, bool include_liftfunc, bool apply_constraints)=0
Quantity of interest derivative function.

libMesh::System::QOIDerivative::~QOIDerivative
virtual ~QOIDerivative()=default
Destructor.

libMesh::System::QOI
Abstract base class to be used for quantities of interest.
Definition system.h:206

libMesh::System::QOI::qoi
virtual void qoi(const QoISet &qoi_indices)=0
Quantity of interest function.

libMesh::System::QOI::~QOI
virtual ~QOI()=default
Destructor.

libMesh::System
Manages consistently variables, degrees of freedom, and coefficient vectors.
Definition system.h:100

libMesh::System::n_vectors
unsigned int n_vectors() const
Definition system.h:2499

libMesh::System::read_serialized_blocked_dof_objects
std::size_t read_serialized_blocked_dof_objects(const dof_id_type n_objects, const iterator_type begin, const iterator_type end, const InValType dummy, Xdr &io, const std::vector< NumericVector< Number > * > &vecs, const unsigned int var_to_read=libMesh::invalid_uint) const
Reads an input vector from the stream io and assigns the values to a set of DofObjects.
Definition system_io.C:618

libMesh::System::user_QOI_derivative
virtual void user_QOI_derivative(const QoISet &qoi_indices=QoISet(), bool include_liftfunc=true, bool apply_constraints=true)
Calls user's attached quantity of interest derivative function, or is overridden by the user in deriv...
Definition system.C:2151

libMesh::System::get_constraint_object
Constraint & get_constraint_object()
Return the user object for imposing constraints.
Definition system.C:2024

libMesh::System::matrices_iterator
std::map< std::string, std::unique_ptr< SparseMatrix< Number > >, std::less<> >::iterator matrices_iterator
Matrix iterator typedefs.
Definition system.h:829

libMesh::System::can_add_matrices
bool can_add_matrices() const
Definition system.h:2028

libMesh::System::extra_quadrature_order
int extra_quadrature_order
A member int that can be employed to indicate increased or reduced quadrature order.
Definition system.h:1640

libMesh::System::_vector_is_adjoint
std::map< std::string, int, std::less<> > _vector_is_adjoint
Holds non-negative if a vector by that name should be projected using adjoint constraints/BCs,...
Definition system.h:2272

libMesh::System::identify_variable_groups
bool identify_variable_groups() const
Definition system.C:2684

libMesh::System::_is_initialized
bool _is_initialized
true when additional vectors and variables do not require immediate initialization,...
Definition system.h:2306

libMesh::System::add_matrix
SparseMatrix< Number > & add_matrix(std::string_view mat_name, ParallelType type=PARALLEL, MatrixBuildType mat_build_type=MatrixBuildType::AUTOMATIC)
Adds the additional matrix mat_name to this system.
Definition system.C:998

libMesh::System::assemble_qoi_derivative
virtual void assemble_qoi_derivative(const QoISet &qoi_indices=QoISet(), bool include_liftfunc=true, bool apply_constraints=true)
Calls user qoi derivative function.
Definition system.C:576

libMesh::System::_init_system_function
void(* _init_system_function)(EquationSystems &es, const std::string &name)
Function that initializes the system.
Definition system.h:2165

libMesh::System::_hide_output
bool _hide_output
Are we allowed to write this system to file? If _hide_output is true, then EquationSystems::write wil...
Definition system.h:2338

libMesh::System::_constrain_system_function
void(* _constrain_system_function)(EquationSystems &es, const std::string &name)
Function to impose constraints.
Definition system.h:2187

libMesh::System::name
const std::string & name() const
Definition system.h:2385

libMesh::System::read_serialized_vectors
std::size_t read_serialized_vectors(Xdr &io, const std::vector< NumericVector< Number > * > &vectors) const
Read a number of identically distributed vectors.
Definition system_io.C:2015

libMesh::System::attach_assemble_object
void attach_assemble_object(Assembly &assemble)
Register a user object to use in assembling the system matrix and RHS.
Definition system.C:1976

libMesh::System::compare
virtual bool compare(const System &other_system, const Real threshold, const bool verbose) const
Definition system.C:606

libMesh::System::attach_constraint_function
void attach_constraint_function(void fptr(EquationSystems &es, const std::string &name))
Register a user function for imposing constraints.
Definition system.C:1990

libMesh::System::solve_for_unconstrained_dofs
void solve_for_unconstrained_dofs(NumericVector< Number > &, int is_adjoint=-1) const
Definition system_projection.C:2103

libMesh::System::const_matrices_iterator
std::map< std::string, std::unique_ptr< SparseMatrix< Number > >, std::less<> >::const_iterator const_matrices_iterator
Definition system.h:830

libMesh::System::weighted_sensitivity_solve
virtual std::pair< unsigned int, Real > weighted_sensitivity_solve(const ParameterVector &parameters, const ParameterVector &weights)
Assembles & solves the linear system(s) (dR/du)*u_w = sum(w_p*-dR/dp), for those parameters p contain...
Definition system.h:2578

libMesh::System::add_weighted_sensitivity_adjoint_solution
NumericVector< Number > & add_weighted_sensitivity_adjoint_solution(unsigned int i=0)
Definition system.C:1252

libMesh::System::adjoint_qoi_parameter_sensitivity
virtual void adjoint_qoi_parameter_sensitivity(const QoISet &qoi_indices, const ParameterVector &parameters, SensitivityData &sensitivities)
Solves for parameter sensitivities using the adjoint method.
Definition system.h:2602

libMesh::System::read_parallel_data
void read_parallel_data(Xdr &io, const bool read_additional_data)
Non-templated version for backward compatibility.
Definition system.h:1412

libMesh::System::reinit
virtual void reinit()
Reinitializes degrees of freedom and other required data on the current mesh.
Definition system.C:442

libMesh::System::assemble_residual_derivatives
virtual void assemble_residual_derivatives(const ParameterVector &parameters)
Calls residual parameter derivative function.
Definition system.h:2553

libMesh::System::_sys_number
const unsigned int _sys_number
The number associated with this system.
Definition system.h:2247

libMesh::System::project_vector
void project_vector(NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=nullptr, int is_adjoint=-1, std::optional< ConstElemRange > active_local_range=std::nullopt, std::optional< std::vector< unsigned int > > variable_numbers=std::nullopt) const
Projects arbitrary functions onto a vector of degree of freedom values for the current system.
Definition system_projection.C:1112

libMesh::System::use_fixed_solution
bool use_fixed_solution
A boolean to be set to true by systems using elem_fixed_solution, for optional use by e....
Definition system.h:1625

libMesh::System::project_solution
void project_solution(FunctionBase< Number > *f, FunctionBase< Gradient > *g=nullptr, std::optional< ConstElemRange > active_local_range=std::nullopt, std::optional< std::vector< unsigned int > > variable_numbers=std::nullopt) const
Projects arbitrary functions onto the current solution.
Definition system_projection.C:1065

libMesh::System::current_solution
Number current_solution(const dof_id_type global_dof_number) const
Definition system.C:162

libMesh::System::get_matrix
const SparseMatrix< Number > & get_matrix(std::string_view mat_name) const
Definition system.C:1111

libMesh::System::qoi_parameter_hessian_vector_product
virtual void qoi_parameter_hessian_vector_product(const QoISet &qoi_indices, const ParameterVector &parameters, const ParameterVector &vector, SensitivityData &product)
For each of the system's quantities of interest q in qoi[qoi_indices], and for a vector of parameters...
Definition system.h:2629

libMesh::System::current_local_solution
std::unique_ptr< NumericVector< Number > > current_local_solution
All the values I need to compute my contribution to the simulation at hand.
Definition system.h:1667

libMesh::System::_assemble_system_object
Assembly * _assemble_system_object
Object that assembles the system.
Definition system.h:2182

libMesh::System::restrict_solve_to
virtual void restrict_solve_to(const SystemSubset *subset, const SubsetSolveMode subset_solve_mode=SUBSET_ZERO)
After calling this method, any solve will be restricted to the given subdomain.
Definition system.C:545

libMesh::System::boundary_project_vector
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=nullptr, int is_adjoint=-1, std::optional< ConstElemRange > active_local_range=std::nullopt) const
Projects arbitrary boundary functions onto a vector of degree of freedom values for the current syste...
Definition system_projection.C:1344

libMesh::System::write_serialized_blocked_dof_objects
std::size_t write_serialized_blocked_dof_objects(const std::vector< const NumericVector< Number > * > &vecs, const dof_id_type n_objects, const iterator_type begin, const iterator_type end, Xdr &io, const unsigned int var_to_write=libMesh::invalid_uint) const
Writes an output vector to the stream io for a set of DofObjects.
Definition system_io.C:1626

libMesh::System::variable
const Variable & variable(unsigned int var) const
Return a constant reference to Variable var.
Definition system.C:2704

libMesh::System::vectors_begin
vectors_iterator vectors_begin()
Beginning of vectors container.
Definition system.h:2505

libMesh::System::vectors_iterator
std::map< std::string, std::unique_ptr< NumericVector< Number > >, std::less<> >::iterator vectors_iterator
Vector iterator typedefs.
Definition system.h:803

libMesh::System::set_qoi
void set_qoi(unsigned int qoi_index, Number qoi_value)
Definition system.C:2176

libMesh::System::activate
void activate()
Activates the system.
Definition system.h:2441

libMesh::System::write_parallel_data
void write_parallel_data(Xdr &io, const bool write_additional_data) const
Writes additional data, namely vectors, for this System.
Definition system_io.C:1318

libMesh::System::write_serialized_vector
dof_id_type write_serialized_vector(Xdr &io, const NumericVector< Number > &vec) const
Writes a vector for this System.
Definition system_io.C:1968

libMesh::System::remove_matrix
void remove_matrix(std::string_view mat_name)
Removes the additional matrix mat_name from this system.
Definition system.C:1076

libMesh::System::_constrain_system_object
Constraint * _constrain_system_object
Object that constrains the system.
Definition system.h:2193

libMesh::System::read_serialized_data
void read_serialized_data(Xdr &io, const bool read_additional_data=true)
Reads additional data, namely vectors, for this System.
Definition system_io.C:533

libMesh::System::get_all_variable_numbers
void get_all_variable_numbers(std::vector< unsigned int > &all_variable_numbers) const
Fills all_variable_numbers with all the variable numbers for the variables that have been added to th...
Definition system.C:1403

libMesh::System::_vectors
std::map< std::string, std::unique_ptr< NumericVector< Number > >, std::less<> > _vectors
Some systems need an arbitrary number of vectors.
Definition system.h:2260

libMesh::System::_matrices
std::map< std::string, std::unique_ptr< SparseMatrix< Number > >, std::less<> > _matrices
Some systems need an arbitrary number of matrices.
Definition system.h:2277

libMesh::System::prefix_with_name
bool prefix_with_name() const
Definition system.h:1974

libMesh::System::user_QOI
virtual void user_QOI(const QoISet &qoi_indices)
Calls user's attached quantity of interest function, or is overridden by the user in derived classes.
Definition system.C:2137

libMesh::System::~System
virtual ~System()
Definition system.C:111

libMesh::System::discrete_var_norm
Real discrete_var_norm(const NumericVector< Number > &v, unsigned int var, FEMNormType norm_type) const
Finds the discrete norm for the entries in the vector corresponding to Dofs associated with var.
Definition system.C:1492

libMesh::System::get_info
std::string get_info() const
Definition system.C:1827

libMesh::System::disable_cache
virtual void disable_cache()
Avoids use of any cached data that might affect any solve result.
Definition system.h:2559

libMesh::System::is_initialized
bool is_initialized() const
Definition system.h:2457

libMesh::System::remove_vector
void remove_vector(std::string_view vec_name)
Removes the additional vector vec_name from this system.
Definition system.C:861

libMesh::System::get_weighted_sensitivity_adjoint_solution
NumericVector< Number > & get_weighted_sensitivity_adjoint_solution(unsigned int i=0)
Definition system.C:1264

libMesh::System::create_static_condensation
virtual void create_static_condensation()
Request that static condensation be performed for this system.
Definition system.C:2664

libMesh::System::system
sys_type & system()
Definition system.h:255

libMesh::System::read_serialized_vector
numeric_index_type read_serialized_vector(Xdr &io, NumericVector< Number > *vec)
Reads a vector for this System.
Definition system_io.C:986

libMesh::System::qoi_parameter_sensitivity
virtual void qoi_parameter_sensitivity(const QoISet &qoi_indices, const ParameterVector &parameters, SensitivityData &sensitivities)
Solves for the derivative of each of the system's quantities of interest q in qoi[qoi_indices] with r...
Definition system.C:590

libMesh::System::n_dofs
dof_id_type n_dofs() const
Definition system.C:118

libMesh::System::_written_var_indices
std::vector< unsigned int > _written_var_indices
This vector is used only when reading in a system from file.
Definition system.h:2325

libMesh::System::vector_name
const std::string & vector_name(const unsigned int vec_num) const
Definition system.C:971

libMesh::System::point_value
Number point_value(unsigned int var, const Point &p, const bool insist_on_success=true, const NumericVector< Number > *sol=nullptr) const
Definition system.C:2219

libMesh::System::matrices_end
matrices_iterator matrices_end()
End of matrices container.
Definition system.h:2541

libMesh::System::variable_type
const FEType & variable_type(const unsigned int i) const
Definition system.C:2721

libMesh::System::boundary_project_solution
void boundary_project_solution(const std::set< boundary_id_type > &b, const std::vector< unsigned int > &variables, FunctionBase< Number > *f, FunctionBase< Gradient > *g=nullptr, std::optional< ConstElemRange > active_local_range=std::nullopt)
Projects arbitrary boundary functions onto a vector of degree of freedom values for the current syste...
Definition system_projection.C:1306

libMesh::System::reinit_mesh
virtual void reinit_mesh()
Reinitializes the system with a new mesh.
Definition system.C:289

libMesh::System::prolong_vectors
virtual void prolong_vectors()
Prolong vectors after the mesh has refined.
Definition system.C:432

libMesh::System::matrices_begin
matrices_iterator matrices_begin()
Beginning of matrices container.
Definition system.h:2529

libMesh::System::_qoi_error_estimates
std::vector< Number > _qoi_error_estimates
Vector to hold error estimates for qois, either from a steady state calculation, or from a single uns...
Definition system.h:2377

libMesh::System::prefix_with_name
void prefix_with_name(bool value)
Instructs this system to prefix solve options with its name for solvers that leverage prefixes.
Definition system.h:1969

libMesh::System::user_initialization
virtual void user_initialization()
Calls user's attached initialization function, or is overridden by the user in derived classes.
Definition system.C:2095

libMesh::System::hide_output
bool & hide_output()
Definition system.h:1852

libMesh::System::read_SCALAR_dofs
unsigned int read_SCALAR_dofs(const unsigned int var, Xdr &io, NumericVector< Number > *vec) const
Reads the SCALAR dofs from the stream io and assigns the values to the appropriate entries of vec.
Definition system_io.C:939

libMesh::System::attach_assemble_function
void attach_assemble_function(void fptr(EquationSystems &es, const std::string &name))
Register a user function to use in assembling the system matrix and RHS.
Definition system.C:1959

libMesh::System::const_vectors_iterator
std::map< std::string, std::unique_ptr< NumericVector< Number > >, std::less<> >::const_iterator const_vectors_iterator
Definition system.h:804

libMesh::System::attach_QOI_function
void attach_QOI_function(void fptr(EquationSystems &es, const std::string &name, const QoISet &qoi_indices))
Register a user function for evaluating the quantities of interest, whose values should be placed in ...
Definition system.C:2032

libMesh::System::add_sensitivity_rhs
NumericVector< Number > & add_sensitivity_rhs(unsigned int i=0)
Definition system.C:1314

libMesh::System::write_header
void write_header(Xdr &io, std::string_view version, const bool write_additional_data) const
Writes the basic data header for this System.
Definition system_io.C:1117

libMesh::System::_qoi_evaluate_object
QOI * _qoi_evaluate_object
Object to compute quantities of interest.
Definition system.h:2205

libMesh::System::ValueFunctionPointer
Number(* ValueFunctionPointer)(const Point &p, const Parameters &Parameters, const std::string &sys_name, const std::string &unknown_name)
Projects arbitrary functions onto the current solution.
Definition system.h:551

libMesh::System::has_constraint_object
bool has_constraint_object() const
Definition system.C:2019

libMesh::System::get_project_with_constraints
bool get_project_with_constraints()
Setter and getter functions for project_with_constraints boolean.
Definition system.h:1837

libMesh::System::attach_init_function
void attach_init_function(void fptr(EquationSystems &es, const std::string &name))
Register a user function to use in initializing the system.
Definition system.C:1928

libMesh::System::vector_is_adjoint
int vector_is_adjoint(std::string_view vec_name) const
Definition system.C:1160

libMesh::System::_basic_system_only
bool _basic_system_only
Holds true if the components of more advanced system types (e.g.
Definition system.h:2300

libMesh::System::_mesh
MeshBase & _mesh
Constant reference to the mesh data structure used for the simulation.
Definition system.h:2237

libMesh::System::assemble_before_solve
bool assemble_before_solve
Flag which tells the system to whether or not to call the user assembly function during each call to ...
Definition system.h:1609

libMesh::System::set_vector_as_adjoint
void set_vector_as_adjoint(const std::string &vec_name, int qoi_num)
Allows one to set the QoI index controlling whether the vector identified by vec_name represents a so...
Definition system.C:1147

libMesh::System::adjoint_solve
virtual std::pair< unsigned int, Real > adjoint_solve(const QoISet &qoi_indices=QoISet())
Solves the adjoint system, for the specified qoi indices, or for every qoi if qoi_indices is nullptr.
Definition system.h:2586

libMesh::System::add_variable
unsigned int add_variable(std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds the variable var to the list of variables for this system.
Definition system.C:1344

libMesh::System::_solution_projection
bool _solution_projection
Holds true if the solution vector should be projected onto a changed grid, false if it should be zero...
Definition system.h:2294

libMesh::System::add_variable_array
unsigned int add_variable_array(const std::vector< std::string > &vars, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds variables vars to the list of variables for this system.
Definition system.C:1386

libMesh::System::add_vector
NumericVector< Number > & add_vector(std::string_view vec_name, const bool projections=true, const ParallelType type=PARALLEL)
Adds the additional vector vec_name to this system.
Definition system.C:756

libMesh::System::set_vector_preservation
void set_vector_preservation(const std::string &vec_name, bool preserve)
Allows one to set the boolean controlling whether the vector identified by vec_name should be "preser...
Definition system.C:1125

libMesh::System::request_vector
const NumericVector< Number > * request_vector(std::string_view vec_name) const
Definition system.C:879

libMesh::System::local_dof_indices
void local_dof_indices(const unsigned int var, std::set< dof_id_type > &var_indices) const
Fills the std::set with the degrees of freedom on the local processor corresponding the the variable ...
Definition system.C:1409

libMesh::System::operator=
System & operator=(const System &)=delete

libMesh::System::restrict_vectors
virtual void restrict_vectors()
Restrict vectors after the mesh has coarsened.
Definition system.C:374

libMesh::System::user_assembly
virtual void user_assembly()
Calls user's attached assembly function, or is overridden by the user in derived classes.
Definition system.C:2109

libMesh::System::n_matrices
unsigned int n_matrices() const
Definition system.h:2638

libMesh::System::weighted_sensitivity_adjoint_solve
virtual std::pair< unsigned int, Real > weighted_sensitivity_adjoint_solve(const ParameterVector &parameters, const ParameterVector &weights, const QoISet &qoi_indices=QoISet())
Assembles & solves the linear system(s) (dR/du)^T*z_w = sum(w_p*(d^2q/dudp - d^2R/dudp*z)),...
Definition system.h:2593

libMesh::System::assemble
virtual void assemble()
Prepares matrix and _dof_map for matrix assembly.
Definition system.C:554

libMesh::System::_qoi_evaluate_function
void(* _qoi_evaluate_function)(EquationSystems &es, const std::string &name, const QoISet &qoi_indices)
Function to evaluate quantity of interest.
Definition system.h:2198

libMesh::System::_prefer_hash_table_matrix_assembly
bool _prefer_hash_table_matrix_assembly
Whether to use hash table matrix assembly if the matrix sub-classes support it.
Definition system.h:2348

libMesh::System::_qoi_evaluate_derivative_object
QOIDerivative * _qoi_evaluate_derivative_object
Object to compute derivatives of quantities of interest.
Definition system.h:2219

libMesh::System::_init_system_object
Initialization * _init_system_object
Object that initializes the system.
Definition system.h:2171

libMesh::System::get_equation_systems
EquationSystems & get_equation_systems()
Definition system.h:772

libMesh::System::n_active_dofs
dof_id_type n_active_dofs() const
Definition system.h:2483

libMesh::System::n_local_dofs
dof_id_type n_local_dofs() const
Definition system.C:155

libMesh::System::system_type
virtual std::string system_type() const
Definition system.h:510

libMesh::System::zero_variable
void zero_variable(NumericVector< Number > &v, unsigned int var_num) const
Zeroes all dofs in v that correspond to variable number var_num.
Definition system.C:1450

libMesh::System::n_constrained_dofs
dof_id_type n_constrained_dofs() const
Definition system.C:125

libMesh::System::get_qoi_value
Number get_qoi_value(unsigned int qoi_index) const
Definition system.C:2184

libMesh::System::n_components
unsigned int n_components() const
Definition system.C:2694

libMesh::System::get_qoi_values
std::vector< Number > get_qoi_values() const
Returns a copy of qoi, not a reference.
Definition system.C:2191

libMesh::System::sys_type
System sys_type
The type of system.
Definition system.h:250

libMesh::System::write_serialized_vectors
std::size_t write_serialized_vectors(Xdr &io, const std::vector< const NumericVector< Number > * > &vectors) const
Serialize & write a number of identically distributed vectors.
Definition system_io.C:2111

libMesh::System::add_sensitivity_solution
NumericVector< Number > & add_sensitivity_solution(unsigned int i=0)
Definition system.C:1169

libMesh::System::init_qois
void init_qois(unsigned int n_qois)
Accessors for qoi and qoi_error_estimates vectors.
Definition system.C:2169

libMesh::System::clear
virtual void clear()
Clear all the data structures associated with the system.
Definition system.C:173

libMesh::System::vectors_end
vectors_iterator vectors_end()
End of vectors container.
Definition system.h:2517

libMesh::System::_vector_projections
std::map< std::string, bool, std::less<> > _vector_projections
Holds true if a vector by that name should be projected onto a changed grid, false if it should be ze...
Definition system.h:2266

libMesh::System::user_constrain
virtual void user_constrain()
Calls user's attached constraint function, or is overridden by the user in derived classes.
Definition system.C:2123

libMesh::System::set_adjoint_already_solved
void set_adjoint_already_solved(bool setting)
Setter for the adjoint_already_solved boolean.
Definition system.h:417

libMesh::System::time
Real time
For time-dependent problems, this is the time t at the beginning of the current timestep.
Definition system.h:1677

libMesh::System::get_sensitivity_solution
NumericVector< Number > & get_sensitivity_solution(unsigned int i=0)
Definition system.C:1179

libMesh::System::add_matrices
virtual void add_matrices()
Insertion point for adding matrices in derived classes before init_matrices() is called.
Definition system.h:2017

libMesh::System::qoi_parameter_hessian
virtual void qoi_parameter_hessian(const QoISet &qoi_indices, const ParameterVector &parameters, SensitivityData &hessian)
For each of the system's quantities of interest q in qoi[qoi_indices], and for a vector of parameters...
Definition system.h:2620

libMesh::System::re_update
virtual void re_update()
Re-update the local values when the mesh has changed.
Definition system.C:521

libMesh::System::_dof_map
std::unique_ptr< DofMap > _dof_map
Data structure describing the relationship between nodes, variables, etc... and degrees of freedom.
Definition system.h:2225

libMesh::System::_equation_systems
EquationSystems & _equation_systems
Constant reference to the EquationSystems object used for the simulation.
Definition system.h:2231

libMesh::System::have_matrix
bool have_matrix(std::string_view mat_name) const
Definition system.h:1933

libMesh::System::deactivate
void deactivate()
Deactivates the system.
Definition system.h:2449

libMesh::System::init
void init()
Initializes degrees of freedom on the current mesh.
Definition system.C:196

libMesh::System::sensitivity_solve
virtual std::pair< unsigned int, Real > sensitivity_solve(const ParameterVector &parameters)
Solves the sensitivity system, for the provided parameters.
Definition system.h:2571

libMesh::System::solution
std::unique_ptr< NumericVector< Number > > solution
Data structure to hold solution values.
Definition system.h:1655

libMesh::System::init_matrices
virtual void init_matrices()
Initializes the matrices associated with this system.
Definition system.C:311

libMesh::System::prefer_hash_table_matrix_assembly
void prefer_hash_table_matrix_assembly(bool preference)
Sets whether to use hash table matrix assembly if the matrix sub-classes support it.
Definition system.h:2667

libMesh::System::variable_group
const VariableGroup & variable_group(unsigned int vg) const
Return a constant reference to VariableGroup vg.
Definition system.C:2709

libMesh::System::_sys_name
const std::string _sys_name
A name associated with this system.
Definition system.h:2242

libMesh::System::GradientFunctionPointer
Gradient(* GradientFunctionPointer)(const Point &p, const Parameters &parameters, const std::string &sys_name, const std::string &unknown_name)
Definition system.h:555

libMesh::System::point_hessian
Tensor point_hessian(unsigned int var, const Point &p, const bool insist_on_success=true, const NumericVector< Number > *sol=nullptr) const
Definition system.C:2492

libMesh::System::init_data
virtual void init_data()
Initializes the data for the system.
Definition system.C:207

libMesh::System::_matrices_initialized
bool _matrices_initialized
false when additional matrices being added require initialization, true otherwise.
Definition system.h:2287

libMesh::System::active
bool active() const
Definition system.h:2433

libMesh::System::project_solution_on_reinit
bool & project_solution_on_reinit(void)
Tells the System whether or not to project the solution vector onto new grids when the system is rein...
Definition system.h:884

libMesh::System::variable_name
const std::string & variable_name(const unsigned int i) const
Definition system.C:2679

libMesh::System::attach_init_object
void attach_init_object(Initialization &init)
Register a user class to use to initialize the system.
Definition system.C:1945

libMesh::System::n_qois
unsigned int n_qois() const
Number of currently active quantities of interest.
Definition system.h:2562

libMesh::System::solve
virtual void solve()
Solves the system.
Definition system.h:349

libMesh::System::get_sensitivity_rhs
NumericVector< Number > & get_sensitivity_rhs(unsigned int i=0)
Definition system.C:1324

libMesh::System::condense_constrained_dofs
virtual bool condense_constrained_dofs() const
Whether this object should condense out constrained degrees of freedom.
Definition system.h:2059

libMesh::System::System
System(System &&)=default

libMesh::System::forward_qoi_parameter_sensitivity
virtual void forward_qoi_parameter_sensitivity(const QoISet &qoi_indices, const ParameterVector &parameters, SensitivityData &sensitivities)
Solves for parameter sensitivities using the forward method.
Definition system.h:2611

libMesh::System::add_adjoint_rhs
NumericVector< Number > & add_adjoint_rhs(unsigned int i=0)
Definition system.C:1284

libMesh::System::set_basic_system_only
void set_basic_system_only()
Sets the system to be "basic only": i.e.
Definition system.h:2465

libMesh::System::add_adjoint_solution
NumericVector< Number > & add_adjoint_solution(unsigned int i=0)
Definition system.C:1220

libMesh::System::assemble_qoi
virtual void assemble_qoi(const QoISet &qoi_indices=QoISet())
Calls user qoi function.
Definition system.C:565

libMesh::System::variable_scalar_number
unsigned int variable_scalar_number(std::string_view var, unsigned int component) const
Definition system.h:2474

libMesh::System::vector_preservation
bool vector_preservation(std::string_view vec_name) const
Definition system.C:1135

libMesh::System::_assemble_system_function
void(* _assemble_system_function)(EquationSystems &es, const std::string &name)
Function that assembles the system.
Definition system.h:2176

libMesh::System::update
virtual void update()
Update the local values to reflect the solution on neighboring processors.
Definition system.C:498

libMesh::System::_qoi
std::vector< Number > _qoi
Values of the quantities of interest.
Definition system.h:2367

libMesh::System::variable_number
unsigned int variable_number(std::string_view var) const
Definition system.C:1398

libMesh::System::n_variable_groups
unsigned int n_variable_groups() const
Definition system.C:2699

libMesh::System::add_variables
unsigned int add_variables(const std::vector< std::string > &vars, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds the variables vars to the list of variables for this system.
Definition system.C:1366

libMesh::System::has_static_condensation
bool has_static_condensation() const
Definition system.C:2669

libMesh::System::System
System(const System &)=delete
Special functions.

libMesh::System::set_qoi_error_estimate
void set_qoi_error_estimate(unsigned int qoi_index, Number qoi_error_estimate)
Definition system.C:2204

libMesh::System::n_local_constrained_dofs
dof_id_type n_local_constrained_dofs() const
Definition system.C:140

libMesh::System::projection_matrix
void projection_matrix(SparseMatrix< Number > &proj_mat) const
This method creates a projection matrix which corresponds to the operation of project_vector between ...
Definition system_projection.C:983

libMesh::System::parameters
Parameters parameters
Parameters for the system. If a parameter is not provided, it should be retrieved from the EquationSy...
Definition system.h:1588

libMesh::System::is_adjoint_already_solved
bool is_adjoint_already_solved() const
Accessor for the adjoint_already_solved boolean.
Definition system.h:411

libMesh::System::has_variable
bool has_variable(std::string_view var) const
Definition system.C:1393

libMesh::System::adjoint_already_solved
bool adjoint_already_solved
Has the adjoint problem already been solved? If the user sets adjoint_already_solved to true,...
Definition system.h:2332

libMesh::System::reinit_constraints
virtual void reinit_constraints()
Reinitializes the constraints for this system.
Definition system.C:483

libMesh::System::point_gradient
Gradient point_gradient(unsigned int var, const Point &p, const bool insist_on_success=true, const NumericVector< Number > *sol=nullptr) const
Definition system.C:2348

libMesh::System::attach_constraint_object
void attach_constraint_object(Constraint &constrain)
Register a user object for imposing constraints.
Definition system.C:2007

libMesh::System::get_weighted_sensitivity_solution
NumericVector< Number > & get_weighted_sensitivity_solution()
Definition system.C:1206

libMesh::System::update_global_solution
void update_global_solution(std::vector< Number > &global_soln) const
Fill the input vector global_soln so that it contains the global solution on all processors.
Definition system.C:733

libMesh::System::calculate_norm
Real calculate_norm(const NumericVector< Number > &v, unsigned int var, FEMNormType norm_type, std::set< unsigned int > *skip_dimensions=nullptr) const
Definition system.C:1511

libMesh::System::attach_QOI_object
void attach_QOI_object(QOI &qoi)
Register a user object for evaluating the quantities of interest, whose values should be placed in Sy...
Definition system.C:2050

libMesh::System::_require_sparsity_pattern
bool _require_sparsity_pattern
Whether any of our matrices require an initial sparsity pattern computation in order to determine pre...
Definition system.h:2353

libMesh::System::set_project_with_constraints
void set_project_with_constraints(bool _project_with_constraints)
Definition system.h:1842

libMesh::System::read_parallel_data
void read_parallel_data(Xdr &io, const bool read_additional_data)
Reads additional data, namely vectors, for this System.
Definition system_io.C:302

libMesh::System::project_with_constraints
bool project_with_constraints
Do we want to apply constraints while projecting vectors ?
Definition system.h:2343

libMesh::System::get_qoi_error_estimate_value
Number get_qoi_error_estimate_value(unsigned int qoi_index) const
Definition system.C:2211

libMesh::System::prefix
std::string prefix() const
Definition system.h:1980

libMesh::System::_prefix_with_name
bool _prefix_with_name
Whether we are name prefixing solver options.
Definition system.h:2358

libMesh::System::add_weighted_sensitivity_solution
NumericVector< Number > & add_weighted_sensitivity_solution()
Definition system.C:1199

libMesh::System::_matrix_types
std::map< std::string, ParallelType, std::less<> > _matrix_types
Holds the types of the matrices.
Definition system.h:2282

libMesh::System::n_vars
unsigned int n_vars() const
Definition system.C:2674

libMesh::System::get_dof_map
const DofMap & get_dof_map() const
Definition system.h:2417

libMesh::System::attach_QOI_derivative
void attach_QOI_derivative(void fptr(EquationSystems &es, const std::string &name, const QoISet &qoi_indices, bool include_liftfunc, bool apply_constraints))
Register a user function for evaluating derivatives of a quantity of interest with respect to test fu...
Definition system.C:2064

libMesh::System::_additional_data_written
unsigned int _additional_data_written
This flag is used only when reading in a system from file.
Definition system.h:2313

libMesh::System::get_adjoint_solution
NumericVector< Number > & get_adjoint_solution(unsigned int i=0)
Definition system.C:1232

libMesh::System::attach_QOI_derivative_object
void attach_QOI_derivative_object(QOIDerivative &qoi_derivative)
Register a user object for evaluating derivatives of a quantity of interest with respect to test func...
Definition system.C:2081

libMesh::System::_active
bool _active
Flag stating if the system is active or not.
Definition system.h:2252

libMesh::System::read_header
void read_header(Xdr &io, std::string_view version, const bool read_header=true, const bool read_additional_data=true, const bool read_legacy_format=false)
Reads the basic data header for this System.
Definition system_io.C:97

libMesh::System::read_serialized_vector
numeric_index_type read_serialized_vector(Xdr &io, NumericVector< Number > &vec)
Non-templated version for backward compatibility.
Definition system.h:2126

libMesh::System::number
unsigned int number() const
Definition system.h:2393

libMesh::System::get_equation_systems
const EquationSystems & get_equation_systems() const
Definition system.h:767

libMesh::System::late_matrix_init
void late_matrix_init(SparseMatrix< Number > &mat, ParallelType type)
Helper function to keep DofMap forward declarable in system.h.
Definition system.C:1063

libMesh::System::get_vector
const NumericVector< Number > & get_vector(std::string_view vec_name) const
Definition system.C:931

libMesh::System::write_SCALAR_dofs
unsigned int write_SCALAR_dofs(const NumericVector< Number > &vec, const unsigned int var, Xdr &io) const
Writes the SCALAR dofs associated with var to the stream io.
Definition system_io.C:1912

libMesh::System::_qoi_evaluate_derivative_function
void(* _qoi_evaluate_derivative_function)(EquationSystems &es, const std::string &name, const QoISet &qoi_indices, bool include_liftfunc, bool apply_constraints)
Function to evaluate quantity of interest derivative.
Definition system.h:2210

libMesh::System::have_vector
bool have_vector(std::string_view vec_name) const
Definition system.h:2491

libMesh::System::get_mesh
const MeshBase & get_mesh() const
Definition system.h:2401

libMesh::System::read_serialized_data
void read_serialized_data(Xdr &io, const bool read_additional_data=true)
Non-templated version for backward compatibility.
Definition system.h:1370

libMesh::System::write_serialized_data
void write_serialized_data(Xdr &io, const bool write_additional_data=true) const
Writes additional data, namely vectors, for this System.
Definition system_io.C:1518

libMesh::System::read_serialized_vectors
std::size_t read_serialized_vectors(Xdr &io, const std::vector< NumericVector< Number > * > &vectors) const
Non-templated version for backward compatibility.
Definition system.h:1390

libMesh::System::request_matrix
const SparseMatrix< Number > * request_matrix(std::string_view mat_name) const
Definition system.C:1087

libMesh::System::get_adjoint_rhs
NumericVector< Number > & get_adjoint_rhs(unsigned int i=0)
Definition system.C:1294

libMesh::TensorValue
This class defines a tensor in LIBMESH_DIM dimensional Real or Complex space.
Definition tensor_value.h:45

libMesh::VariableGroup
This class defines a logically grouped set of variables in the system.
Definition variable.h:216

libMesh::Variable
This class defines the notion of a variable in the system.
Definition variable.h:51

libMesh::VectorValue
This class defines a vector in LIBMESH_DIM dimensional Real or Complex space.
Definition vector_value.h:48

libMesh::Xdr
This class implements a C++ interface to the XDR (eXternal Data Representation) format.
Definition xdr_cxx.h:68

b
static const Real b
Definition disjoint_neighbor_test.C:24

libMesh
The libMesh namespace provides an interface to certain functionality in the library.

libMesh::ParallelType
ParallelType
Defines an enum for parallel data structure types.
Definition enum_parallel_type.h:33

libMesh::PARALLEL
@ PARALLEL
Definition enum_parallel_type.h:36

libMesh::FEMNormType
FEMNormType
Definition enum_norm_type.h:34

libMesh::SubsetSolveMode
SubsetSolveMode
defines an enum for the question what happens to the dofs outside the given subset when a system is s...
Definition enum_subset_solve_mode.h:35

libMesh::SUBSET_ZERO
@ SUBSET_ZERO
Definition enum_subset_solve_mode.h:37

libMesh::Gradient
NumberVectorValue Gradient
Definition exact_solution.h:51

libMesh::MatrixBuildType
MatrixBuildType
Defines an enum for matrix build types.
Definition enum_matrix_build_type.h:30

libMesh::MatrixBuildType::AUTOMATIC
@ AUTOMATIC

libMesh::invalid_uint
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition libmesh.h:303

libMesh::numeric_index_type
dof_id_type numeric_index_type
Definition id_types.h:99

libMesh::Number
Real Number
Definition libmesh_common.h:253

libMesh::dof_id_type
uint8_t dof_id_type
Definition id_types.h:67

libMesh::FEFamily
FEFamily
Definition enum_fe_family.h:34

libMesh::LAGRANGE
@ LAGRANGE
Definition enum_fe_family.h:36

libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition libmesh_common.h:144

libMesh::processor_id_type
uint8_t processor_id_type
Definition id_types.h:104

libMesh::Order
Order
Definition enum_order.h:40

libMesh::FIRST
@ FIRST
Definition enum_order.h:42

libMesh::NumberVectorValue
VectorValue< Number > NumberVectorValue
Definition exact_solution.h:50

gptr
Gradient gptr(const Point &p, const Parameters &, const std::string &libmesh_dbg_var(sys_name), const std::string &unknown_name)
Definition projection.C:96

fptr
Number fptr(const Point &p, const Parameters &, const std::string &libmesh_dbg_var(sys_name), const std::string &unknown_name)
Definition projection.C:81

value
static const bool value
Definition xdr_io.C:55