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 (const std::set< boundary_id_type > &b_in, const 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. More...
	DirichletBoundary (const std::set< boundary_id_type > &b_in, const std::vector< unsigned int > &variables_in, const FunctionBase< Number > &f_in, VariableIndexing type=SYSTEM_VARIABLE_ORDER)
	Constructor for a boundary from reference-to-functor. More...
	DirichletBoundary (const std::set< boundary_id_type > &b_in, const 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. More...
	DirichletBoundary (const std::set< boundary_id_type > &b_in, const 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. More...
	DirichletBoundary (const std::set< boundary_id_type > &b_in, const 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. More...
	DirichletBoundary (const std::set< boundary_id_type > &b_in, const 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. More...
	DirichletBoundary (const DirichletBoundary &dirichlet_in)
	Copy constructor. More...
	~DirichletBoundary ()
	Standard destructor. More...

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

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/7]

libMesh::DirichletBoundary::DirichletBoundary	(	const std::set< boundary_id_type > &	b_in,
		const 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 34 of file dirichlet_boundary.C.

                                                       :
  b(b_in),
  variables(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/7]

libMesh::DirichletBoundary::DirichletBoundary	(	const std::set< boundary_id_type > &	b_in,
		const 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 53 of file dirichlet_boundary.C.

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

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

DirichletBoundary() [3/7]

libMesh::DirichletBoundary::DirichletBoundary	(	const std::set< boundary_id_type > &	b_in,
		const 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 76 of file dirichlet_boundary.C.

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

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

DirichletBoundary() [4/7]

libMesh::DirichletBoundary::DirichletBoundary	(	const std::set< boundary_id_type > &	b_in,
		const 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 108 of file dirichlet_boundary.C.

                                                          :
  b(b_in),
  variables(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/7]

libMesh::DirichletBoundary::DirichletBoundary	(	const std::set< boundary_id_type > &	b_in,
		const 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 125 of file dirichlet_boundary.C.

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

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

DirichletBoundary() [6/7]

libMesh::DirichletBoundary::DirichletBoundary	(	const std::set< boundary_id_type > &	b_in,
		const 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 147 of file dirichlet_boundary.C.

                                         :
  b(b_in),
  variables(variables_in),
  f_system(&f_sys_in),
  jacobian_tolerance(0.)
{
  if (type == LOCAL_VARIABLE_ORDER)
    {
      auto cf = libmesh_make_unique<CompositeFEMFunction<Number>>();
      cf->attach_subfunction(f_in, variables_in);
      f_fem = std::move(cf);
 
      auto cg = libmesh_make_unique<CompositeFEMFunction<Gradient>>();
      cg->attach_subfunction(g_in, variables_in);
      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, and libMesh::LOCAL_VARIABLE_ORDER.

DirichletBoundary() [7/7]

libMesh::DirichletBoundary::DirichletBoundary

(

const DirichletBoundary &

dirichlet_in

)

Copy constructor.

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

Definition at line 177 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()

libMesh::DirichletBoundary::~DirichletBoundary

(

)

Standard destructor.

Definition at line 199 of file dirichlet_boundary.C.

{}

Member Data Documentation

b

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

Definition at line 173 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 176 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary().

f_fem

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

Definition at line 179 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary().

f_system

const System* libMesh::DirichletBoundary::f_system

Definition at line 182 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary().

g

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

Definition at line 177 of file dirichlet_boundaries.h.

Referenced by DirichletBoundary().

g_fem

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

Definition at line 180 of file dirichlet_boundaries.h.

Referenced by 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 196 of file dirichlet_boundaries.h.

variables

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

Definition at line 174 of file dirichlet_boundaries.h.

Referenced by 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