libMesh::DirichletBoundary Class Reference

This class allows one to associate Dirichlet boundary values with a given set of mesh boundary ids and system variable ids. More...

#include <dirichlet_boundaries.h>

Public Member Functions
	DirichletBoundary (std::set< boundary_id_type > b_in, std::vector< unsigned int > variables_in, const FunctionBase< Number > *f_in, const FunctionBase< Gradient > *g_in=nullptr)
	Constructor for a system-variable-order boundary using pointers-to-functors.
	DirichletBoundary (std::set< boundary_id_type > b_in, std::vector< unsigned int > variables_in, const FunctionBase< Number > &f_in, VariableIndexing type=SYSTEM_VARIABLE_ORDER)
	Constructor for a boundary from reference-to-functor.
	DirichletBoundary (std::set< boundary_id_type > b_in, std::vector< unsigned int > variables_in, const FunctionBase< Number > &f_in, const FunctionBase< Gradient > &g_in, VariableIndexing type=SYSTEM_VARIABLE_ORDER)
	Constructor for a system-variable-order boundary from references-to-functors.
	DirichletBoundary (std::set< boundary_id_type > b_in, std::vector< unsigned int > variables_in, const System &f_sys_in, const FEMFunctionBase< Number > *f_in, const FEMFunctionBase< Gradient > *g_in=nullptr)
	Constructor for a system-variable-order boundary from pointers-to-fem-functors.
	DirichletBoundary (std::set< boundary_id_type > b_in, std::vector< unsigned int > variables_in, const System &f_sys_in, const FEMFunctionBase< Number > &f_in, VariableIndexing type=SYSTEM_VARIABLE_ORDER)
	Constructor for a system-variable-order boundary from reference-to-fem-functor.
	DirichletBoundary (std::set< boundary_id_type > b_in, std::vector< unsigned int > variables_in, const System &f_sys_in, const FEMFunctionBase< Number > &f_in, const FEMFunctionBase< Gradient > &g_in, VariableIndexing type=SYSTEM_VARIABLE_ORDER)
	Constructor for a system-variable-order boundary from references-to-fem-functors.
	DirichletBoundary (const DirichletBoundary &dirichlet_in)
	Copy assignment/constructor.
DirichletBoundary &	operator= (const DirichletBoundary &)
	DirichletBoundary (DirichletBoundary &&)=default
	This class is default move-assignable and move-constructible.
DirichletBoundary &	operator= (DirichletBoundary &&)=default
	~DirichletBoundary ()
	Standard destructor.

Public Attributes
std::set< boundary_id_type >	b
std::vector< unsigned int >	variables
std::unique_ptr< FunctionBase< Number > >	f
std::unique_ptr< FunctionBase< Gradient > >	g
std::unique_ptr< FEMFunctionBase< Number > >	f_fem
std::unique_ptr< FEMFunctionBase< Gradient > >	g_fem
const System *	f_system
Real	jacobian_tolerance
	Defaults to zero, but can be set to a custom small negative value to try and avoid spurious zero (or negative) Jacobian values when applying Dirichlet constraints.

Detailed Description

This class allows one to associate Dirichlet boundary values with a given set of mesh boundary ids and system variable ids.

Dirichlet values must be supplied as the input function "f"; when using some specialized elements, gradient values must be supplied via the input function "g".

Dirichlet functions may be subclasses of FunctionBase or FEMFunctionBase; in the latter case the user must also supply a reference to the System on which the FEMFunctionBase will be evaluated.

Dirichlet functions are allowed to return NaN; if this is encountered, then the degree of freedom values in a patch around the location of the returned NaN will be left unconstrained. E.g. a NaN on a boundary edge in 3D would leave that edge and the two adjoining face interiors unconstrained, but would still permit the other edge and node DoFs around those faces to be constrained.

Author

Roy Stogner

Date

2012

Class for specifying Dirichlet boundary conditions as constraints.

Definition at line 88 of file dirichlet_boundaries.h.

Constructor & Destructor Documentation

DirichletBoundary() [1/8]

libMesh::DirichletBoundary::DirichletBoundary	(	std::set< boundary_id_type >	b_in,
		std::vector< unsigned int >	variables_in,
		const FunctionBase< Number > *	f_in,
		const FunctionBase< Gradient > *	g_in = nullptr
	)

Constructor for a system-variable-order boundary using pointers-to-functors.

Definition at line 35 of file dirichlet_boundary.C.

                                                       :
  b(std::move(b_in)),
  variables(std::move(variables_in)),
  f(f_in ? f_in->clone() : nullptr),
  g(g_in ? g_in->clone() : nullptr),
  f_system(nullptr),
  jacobian_tolerance(0.)
{
  libmesh_assert(f);
  f->init();
  if (g)
    g->init();
}

References f, g, and libMesh::libmesh_assert().

DirichletBoundary() [2/8]

libMesh::DirichletBoundary::DirichletBoundary	(	std::set< boundary_id_type >	b_in,
		std::vector< unsigned int >	variables_in,
		const FunctionBase< Number > &	f_in,
		VariableIndexing	type = SYSTEM_VARIABLE_ORDER
	)

Constructor for a boundary from reference-to-functor.

Defaults to system variable indexing for backwards compatibility, but most users will prefer local indexing.

Definition at line 54 of file dirichlet_boundary.C.

                                         :
  b(std::move(b_in)),
  variables(std::move(variables_in)),
  f_system(nullptr),
  jacobian_tolerance(0.)
{
  if (type == LOCAL_VARIABLE_ORDER)
    {
      auto c = std::make_unique<CompositeFunction<Number>>();
      c->attach_subfunction(f_in, variables);
      f = std::move(c);
    }
  else
    f = f_in.clone();
 
  f->init();
}

References libMesh::FunctionBase< Output >::clone(), f, libMesh::LOCAL_VARIABLE_ORDER, and variables.

DirichletBoundary() [3/8]

libMesh::DirichletBoundary::DirichletBoundary	(	std::set< boundary_id_type >	b_in,
		std::vector< unsigned int >	variables_in,
		const FunctionBase< Number > &	f_in,
		const FunctionBase< Gradient > &	g_in,
		VariableIndexing	type = SYSTEM_VARIABLE_ORDER
	)

Constructor for a system-variable-order boundary from references-to-functors.

Defaults to system variable indexing for backwards compatibility, but most users will prefer local indexing.

Definition at line 77 of file dirichlet_boundary.C.

                                         :
  b(std::move(b_in)),
  variables(std::move(variables_in)),
  f_system(nullptr),
  jacobian_tolerance(0.)
{
  if (type == LOCAL_VARIABLE_ORDER)
    {
      auto cf = std::make_unique<CompositeFunction<Number>>();
      cf->attach_subfunction(f_in, variables);
      f = std::move(cf);
 
      auto cg = std::make_unique<CompositeFunction<Gradient>>();
      cg->attach_subfunction(g_in, variables);
      g = std::move(cg);
    }
  else
    {
      f = f_in.clone();
      g = g_in.clone();
    }
 
  f->init();
  g->init();
}

References libMesh::FunctionBase< Output >::clone(), f, g, libMesh::LOCAL_VARIABLE_ORDER, and variables.

DirichletBoundary() [4/8]

libMesh::DirichletBoundary::DirichletBoundary	(	std::set< boundary_id_type >	b_in,
		std::vector< unsigned int >	variables_in,
		const System &	f_sys_in,
		const FEMFunctionBase< Number > *	f_in,
		const FEMFunctionBase< Gradient > *	g_in = nullptr
	)

Constructor for a system-variable-order boundary from pointers-to-fem-functors.

Definition at line 109 of file dirichlet_boundary.C.

                                                          :
  b(std::move(b_in)),
  variables(std::move(variables_in)),
  f_fem(f_in ? f_in->clone() : nullptr),
  g_fem(g_in ? g_in->clone() : nullptr),
  f_system(&f_sys_in),
  jacobian_tolerance(0.)
{
  libmesh_assert(f_fem);
}

References f_fem, and libMesh::libmesh_assert().

DirichletBoundary() [5/8]

libMesh::DirichletBoundary::DirichletBoundary	(	std::set< boundary_id_type >	b_in,
		std::vector< unsigned int >	variables_in,
		const System &	f_sys_in,
		const FEMFunctionBase< Number > &	f_in,
		VariableIndexing	type = SYSTEM_VARIABLE_ORDER
	)

Constructor for a system-variable-order boundary from reference-to-fem-functor.

Defaults to system variable indexing for backwards compatibility, but most users will prefer local indexing.

Definition at line 126 of file dirichlet_boundary.C.

                                         :
  b(std::move(b_in)),
  variables(std::move(variables_in)),
  f_system(&f_sys_in),
  jacobian_tolerance(0.)
{
  if (type == LOCAL_VARIABLE_ORDER)
    {
      auto c = std::make_unique<CompositeFEMFunction<Number>>();
      c->attach_subfunction(f_in, variables);
      f_fem = std::move(c);
    }
  else
    f_fem = f_in.clone();
}

References libMesh::FEMFunctionBase< Output >::clone(), f_fem, libMesh::LOCAL_VARIABLE_ORDER, and variables.

DirichletBoundary() [6/8]

libMesh::DirichletBoundary::DirichletBoundary	(	std::set< boundary_id_type >	b_in,
		std::vector< unsigned int >	variables_in,
		const System &	f_sys_in,
		const FEMFunctionBase< Number > &	f_in,
		const FEMFunctionBase< Gradient > &	g_in,
		VariableIndexing	type = SYSTEM_VARIABLE_ORDER
	)

Constructor for a system-variable-order boundary from references-to-fem-functors.

Defaults to system variable indexing for backwards compatibility, but most users will prefer local indexing.

Definition at line 148 of file dirichlet_boundary.C.

                                         :
  b(std::move(b_in)),
  variables(std::move(variables_in)),
  f_system(&f_sys_in),
  jacobian_tolerance(0.)
{
  if (type == LOCAL_VARIABLE_ORDER)
    {
      auto cf = std::make_unique<CompositeFEMFunction<Number>>();
      cf->attach_subfunction(f_in, variables);
      f_fem = std::move(cf);
 
      auto cg = std::make_unique<CompositeFEMFunction<Gradient>>();
      cg->attach_subfunction(g_in, variables);
      g_fem = std::move(cg);
    }
  else
    {
      f_fem = f_in.clone();
      g_fem = g_in.clone();
    }
}

References libMesh::FEMFunctionBase< Output >::clone(), f_fem, g_fem, libMesh::LOCAL_VARIABLE_ORDER, and variables.

DirichletBoundary() [7/8]

libMesh::DirichletBoundary::DirichletBoundary

(

const DirichletBoundary &

dirichlet_in

)

Copy assignment/constructor.

Deep copies (clones) functors; shallow copies any System reference

Definition at line 178 of file dirichlet_boundary.C.

                                                  :
  b(d_in.b),
  variables(d_in.variables),
  f(d_in.f ? d_in.f->clone() : nullptr),
  g(d_in.g ? d_in.g->clone() : nullptr),
  f_fem(d_in.f_fem ? d_in.f_fem->clone() : nullptr),
  g_fem(d_in.g_fem ? d_in.g_fem->clone() : nullptr),
  f_system(d_in.f_system),
  jacobian_tolerance(d_in.jacobian_tolerance)
{
  libmesh_assert(f || f_fem);
  libmesh_assert(!(f && f_fem));
  libmesh_assert(!(f && g_fem));
  libmesh_assert(!(f_fem && g));
  libmesh_assert(!(f_fem && !f_system));
  if (f)
    f->init();
  if (g)
    g->init();
}

References f, f_fem, f_system, g, g_fem, and libMesh::libmesh_assert().

DirichletBoundary() [8/8]

libMesh::DirichletBoundary::DirichletBoundary ( DirichletBoundary &&  )

default

This class is default move-assignable and move-constructible.

~DirichletBoundary()

libMesh::DirichletBoundary::~DirichletBoundary ( )

default

Standard destructor.

Member Function Documentation

operator=() [1/2]

DirichletBoundary & libMesh::DirichletBoundary::operator=

(

const DirichletBoundary &

rhs

)

Definition at line 201 of file dirichlet_boundary.C.

{
  // Implementation in terms of the copy constructor to avoid code duplication.
  DirichletBoundary tmp(rhs);
  std::swap(tmp, *this); // class must be "MoveAssignable" and "MoveConstructible" for std::swap to work.
  return *this;
}

operator=() [2/2]

DirichletBoundary & libMesh::DirichletBoundary::operator= ( DirichletBoundary &&  )

default

Member Data Documentation

b

std::set<boundary_id_type> libMesh::DirichletBoundary::b

Definition at line 180 of file dirichlet_boundaries.h.

Referenced by libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::DofMap::remove_adjoint_dirichlet_boundary(), and libMesh::DofMap::remove_dirichlet_boundary().

f

std::unique_ptr<FunctionBase<Number> > libMesh::DirichletBoundary::f

Definition at line 183 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary(), DirichletBoundary(), DirichletBoundary(), and DirichletBoundary().

f_fem

std::unique_ptr<FEMFunctionBase<Number> > libMesh::DirichletBoundary::f_fem

Definition at line 186 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary(), DirichletBoundary(), DirichletBoundary(), and DirichletBoundary().

f_system

const System* libMesh::DirichletBoundary::f_system

Definition at line 189 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary().

g

std::unique_ptr<FunctionBase<Gradient> > libMesh::DirichletBoundary::g

Definition at line 184 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary(), DirichletBoundary(), and DirichletBoundary().

g_fem

std::unique_ptr<FEMFunctionBase<Gradient> > libMesh::DirichletBoundary::g_fem

Definition at line 187 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary(), and DirichletBoundary().

jacobian_tolerance

Real libMesh::DirichletBoundary::jacobian_tolerance

Defaults to zero, but can be set to a custom small negative value to try and avoid spurious zero (or negative) Jacobian values when applying Dirichlet constraints.

This can be useful in various different situations, for example: 1.) When specifying DirichletBCs on poorly-shaped elements. 2.) When degenerate Hexahedra are used in place of Prisms for convenience. 3.) On elements (e.g. Pyramids) which always have a zero Jacobian at the "apex" node. In theory there's nothing preventing someone from specifying DirichletBCs in such cases; setting this tolerance to a small negative value makes this possible in practice.

Definition at line 203 of file dirichlet_boundaries.h.

variables

std::vector<unsigned int> libMesh::DirichletBoundary::variables

Definition at line 181 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary(), DirichletBoundary(), DirichletBoundary(), DirichletBoundary(), libMesh::DofMap::remove_adjoint_dirichlet_boundary(), and libMesh::DofMap::remove_dirichlet_boundary().

---

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

• include/base/dirichlet_boundaries.h
• src/base/dirichlet_boundary.C