Class for specifying Dirichlet boundary conditions as constraints. 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)

	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)

	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)

	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)

	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)

	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)

	DirichletBoundary (const DirichletBoundary &dirichlet_in)

	~DirichletBoundary ()

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

Detailed Description

Class for specifying Dirichlet boundary conditions as constraints.

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

Definition at line 89 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.

References f, and g.

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

◆ 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 52 of file dirichlet_boundary.C.

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

                                          :
   b(b_in),
   variables(variables_in),
   f_system(nullptr)
 {
   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();
 }

◆ 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 74 of file dirichlet_boundary.C.

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

                                          :
   b(b_in),
   variables(variables_in),
   f_system(nullptr)
 {
   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();
 }

◆ 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 105 of file dirichlet_boundary.C.

References f_fem.

                                                           :
   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)
 {
   libmesh_assert(f_fem);
 }

◆ 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 121 of file dirichlet_boundary.C.

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

                                          :
   b(b_in),
   variables(variables_in),
   f_system(&f_sys_in)
 {
   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();
 }

◆ 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 142 of file dirichlet_boundary.C.

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

                                          :
   b(b_in),
   variables(variables_in),
   f_system(&f_sys_in)
 {
   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();
     }
 }

◆ DirichletBoundary() [7/7]

libMesh::DirichletBoundary::DirichletBoundary ( const DirichletBoundary & dirichlet_in )

Copy constructor. Deep copies (clones) functors; shallow copies any System reference

Definition at line 171 of file dirichlet_boundary.C.

References f, f_fem, f_system, g, and g_fem.

                                                   :
   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)
 {
   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();
 }