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

#include <dirichlet_boundaries.h>

Public 成员函数
	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 属性
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. 更多...

详细描述

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.

作者: Roy Stogner

日期: 2012 Class for specifying Dirichlet boundary conditions as constraints.

在文件 dirichlet_boundaries.h 第 88 行定义.

构造及析构函数说明

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.

在文件 dirichlet_boundary.C 第 36 行定义.

参考 f , 以及 g.

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

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.

在文件 dirichlet_boundary.C 第 55 行定义.

参考 libMesh::FunctionBase< Output >::clone(), f, libMesh::LOCAL_VARIABLE_ORDER , 以及 variables.

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

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.

在文件 dirichlet_boundary.C 第 78 行定义.

参考 libMesh::FunctionBase< Output >::clone(), f, g, libMesh::LOCAL_VARIABLE_ORDER , 以及 variables.

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

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.

在文件 dirichlet_boundary.C 第 110 行定义.

参考 f_fem.

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

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.

在文件 dirichlet_boundary.C 第 127 行定义.

参考 libMesh::FEMFunctionBase< Output >::clone(), f_fem, libMesh::LOCAL_VARIABLE_ORDER , 以及 variables.

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

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.

在文件 dirichlet_boundary.C 第 149 行定义.

参考 libMesh::FEMFunctionBase< Output >::clone(), f_fem, g_fem, libMesh::LOCAL_VARIABLE_ORDER , 以及 variables.

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

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

Copy assignment/constructor.

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

在文件 dirichlet_boundary.C 第 179 行定义.

参考 f, f_fem, f_system, g , 以及 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),
   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();
 }

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

default

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

libMesh::DirichletBoundary::~DirichletBoundary ( )

default

Standard destructor.

成员函数说明

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

在文件 dirichlet_boundary.C 第 201 行定义.

 {
   // 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;
 }

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

default

类成员变量说明

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

在文件 dirichlet_boundaries.h 第 180 行定义.

参考自 libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::DofMap::remove_adjoint_dirichlet_boundary() , 以及 libMesh::DofMap::remove_dirichlet_boundary().

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

在文件 dirichlet_boundaries.h 第 183 行定义.

参考自 DirichletBoundary().

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

在文件 dirichlet_boundaries.h 第 186 行定义.

参考自 DirichletBoundary().

const System* libMesh::DirichletBoundary::f_system

在文件 dirichlet_boundaries.h 第 189 行定义.

参考自 DirichletBoundary().

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

在文件 dirichlet_boundaries.h 第 184 行定义.

参考自 DirichletBoundary().

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

在文件 dirichlet_boundaries.h 第 187 行定义.

参考自 DirichletBoundary().

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.

在文件 dirichlet_boundaries.h 第 203 行定义.

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

在文件 dirichlet_boundaries.h 第 181 行定义.

参考自 DirichletBoundary(), libMesh::DofMap::remove_adjoint_dirichlet_boundary() , 以及 libMesh::DofMap::remove_dirichlet_boundary().

该类的文档由以下文件生成:

/home/lwz/libmesh/include/base/dirichlet_boundaries.h
/home/lwz/libmesh/src/base/dirichlet_boundary.C

Public 成员函数

Public 属性

详细描述

构造及析构函数说明

成员函数说明

类成员变量说明