/class BoundaryRestrictable /brief Provides functionality for limiting the object to certain boundary ids The is class the inheriting class with methods useful for limiting an object to certain boundaries. More...

#include <BoundaryRestrictable.h>

Inheritance diagram for BoundaryRestrictable:

[legend]

Public Types
enum	TEST_TYPE { ALL, ANY }
	A flag changing the behavior of hasBoundary. More...

Public Member Functions
	BoundaryRestrictable (const MooseObject *moose_object, bool nodal)
	Class constructor Populates the _bnd_ids for the given boundary names supplied with the 'boundary' input parameter. More...

	BoundaryRestrictable (const MooseObject *moose_object, const std::set< SubdomainID > &block_ids, bool nodal)
	Class constructor Populates the 'block' input parameters when an object is also block restricted, see the general class documentation for details. More...

virtual	~BoundaryRestrictable ()
	Empty class destructor. More...

const virtual std::set< BoundaryID > &	boundaryIDs () const
	Return the boundary IDs for this object. More...

const std::vector< BoundaryName > &	boundaryNames () const
	Return the boundary names for this object. More...

unsigned int	numBoundaryIDs () const
	Return the number of boundaries for this object. More...

bool	hasBoundary (const BoundaryName &name) const
	Test if the supplied boundary name is valid for this object. More...

bool	hasBoundary (const std::vector< BoundaryName > &names) const
	Test if the supplied vector of boundary names are valid for this object. More...

bool	hasBoundary (const BoundaryID &id) const
	Test if the supplied boundary ids are valid for this object. More...

bool	hasBoundary (const std::vector< BoundaryID > &ids, TEST_TYPE type=ALL) const
	Test if the supplied vector boundary ids are valid for this object. More...

bool	hasBoundary (const std::set< BoundaryID > &ids, TEST_TYPE type=ALL) const
	Test if the supplied set of boundary ids are valid for this object. More...

bool	isBoundarySubset (const std::set< BoundaryID > &ids) const
	Test if the class boundary ids are a subset of the supplied objects. More...

bool	isBoundarySubset (const std::vector< BoundaryID > &ids) const

template<typename T >
bool	hasBoundaryMaterialProperty (const std::string &prop_name) const
	Check if a material property is valid for all boundaries of this object. More...

virtual bool	boundaryRestricted () const
	Returns true if this object has been restricted to a boundary. More...

const std::set< BoundaryID > &	meshBoundaryIDs () const
	Returns the set of all boundary ids for the entire mesh. More...

Static Public Member Functions
static InputParameters	validParams ()

static bool	restricted (const std::set< BoundaryID > &ids)
	Helper for determining if the object is boundary restricted. More...

Protected Member Functions
bool	hasBoundaryMaterialPropertyHelper (const std::string &prop_name) const
	A helper method to avoid circular #include problems. More...

Private Member Functions
void	initializeBoundaryRestrictable (const MooseObject *moose_object)
	An initialization routine needed for dual constructors. More...

Private Attributes
FEProblemBase *	_bnd_feproblem
	Pointer to FEProblemBase. More...

MooseMesh *	_bnd_mesh
	Point to mesh. More...

std::set< BoundaryID >	_bnd_ids
	Set of the boundary ids. More...

std::vector< BoundaryName >	_boundary_names
	Vector the the boundary names. More...

const bool	_bnd_dual_restrictable
	Flag for allowing dual restriction with BlockRestrictable. More...

const std::set< SubdomainID >	_empty_block_ids
	An empty set for referencing when block_ids is not included. More...

const std::set< SubdomainID > &	_block_ids
	Reference to the block_ids, defaults to an empty set if not provided. More...

THREAD_ID	_bnd_tid
	Thread id for this object. More...

std::shared_ptr< MaterialData >	_bnd_material_data
	Pointer to MaterialData for boundary (. More...

bool	_bnd_nodal
	Whether or not this object is restricted to nodesets. More...

Detailed Description

/class BoundaryRestrictable /brief Provides functionality for limiting the object to certain boundary ids The is class the inheriting class with methods useful for limiting an object to certain boundaries.

The parameters "_boundary_id" and "boundary", which are created with validParams<BoundaryRestrictable> are used the framework.

Definition at line 30 of file BoundaryRestrictable.h.

Member Enumeration Documentation

◆ TEST_TYPE

enum BoundaryRestrictable::TEST_TYPE

A flag changing the behavior of hasBoundary.

Enumerator
ALL
ANY

Definition at line 34 of file BoundaryRestrictable.h.

   {
     ALL,
     ANY
   };

Constructor & Destructor Documentation

◆ BoundaryRestrictable() [1/2]

BoundaryRestrictable::BoundaryRestrictable	(	const MooseObject *	moose_object,
		bool	nodal
	)

Class constructor Populates the _bnd_ids for the given boundary names supplied with the 'boundary' input parameter.

Parameters

parameters	The input parameters
nodal	True indicates that the object is operating on nodesets, false for sidesets

Definition at line 38 of file BoundaryRestrictable.C.

   : _bnd_feproblem(moose_object->isParamValid("_fe_problem_base")
                        ? moose_object->getParamTempl<FEProblemBase *>("_fe_problem_base")
                        : NULL),
     _bnd_mesh(moose_object->isParamValid("_mesh")
                   ? moose_object->getParamTempl<MooseMesh *>("_mesh")
                   : NULL),
     _bnd_dual_restrictable(moose_object->getParamTempl<bool>("_dual_restrictable")),
     _block_ids(_empty_block_ids),
     _bnd_tid(moose_object->isParamValid("_tid") ? moose_object->getParamTempl<THREAD_ID>("_tid")
                                                 : 0),
     _bnd_material_data(_bnd_feproblem->getMaterialData(Moose::BOUNDARY_MATERIAL_DATA, _bnd_tid)),
     _bnd_nodal(nodal)
 {
   initializeBoundaryRestrictable(moose_object);
 }

◆ BoundaryRestrictable() [2/2]

BoundaryRestrictable::BoundaryRestrictable	(	const MooseObject *	moose_object,
		const std::set< SubdomainID > &	block_ids,
		bool	nodal
	)

Class constructor Populates the 'block' input parameters when an object is also block restricted, see the general class documentation for details.

Parameters

parameters	The input parameters (see the detailed help for additional information)
block_ids	The block ids that the object is restricted to
nodal	True indicates that the object is operating on nodesets, false for sidesets

Definition at line 56 of file BoundaryRestrictable.C.

   : _bnd_feproblem(moose_object->isParamValid("_fe_problem_base")
                        ? moose_object->getParamTempl<FEProblemBase *>("_fe_problem_base")
                        : NULL),
     _bnd_mesh(moose_object->isParamValid("_mesh")
                   ? moose_object->getParamTempl<MooseMesh *>("_mesh")
                   : NULL),
     _bnd_dual_restrictable(moose_object->getParamTempl<bool>("_dual_restrictable")),
     _block_ids(block_ids),
     _bnd_tid(moose_object->isParamValid("_tid") ? moose_object->getParamTempl<THREAD_ID>("_tid")
                                                 : 0),
     _bnd_material_data(_bnd_feproblem->getMaterialData(Moose::BOUNDARY_MATERIAL_DATA, _bnd_tid)),
     _bnd_nodal(nodal)
 {
   initializeBoundaryRestrictable(moose_object);
 }

◆ ~BoundaryRestrictable()

BoundaryRestrictable::~BoundaryRestrictable ( )

virtual

Empty class destructor.

Definition at line 167 of file BoundaryRestrictable.C.

167 {}

Member Function Documentation

◆ boundaryIDs()

const std::set< BoundaryID > & BoundaryRestrictable::boundaryIDs ( ) const

virtual

Return the boundary IDs for this object.

Returns: A set of all boundary ids for which the object is restricted

Definition at line 170 of file BoundaryRestrictable.C.

 {
   return _bnd_ids;
 }

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addInterfaceKernel(), MaterialBase::getZeroMaterialProperty(), hasBoundaryMaterialPropertyHelper(), SidesetInfoVectorPostprocessor::initialize(), InterfaceQpValueUserObject::initialize(), and MaterialBase::registerPropName().

◆ boundaryNames()

const std::vector< BoundaryName > & BoundaryRestrictable::boundaryNames ( ) const

Return the boundary names for this object.

Returns: A set of all boundary names for which the object is restricted

Definition at line 176 of file BoundaryRestrictable.C.

 {
   return _boundary_names;
 }

Referenced by MaterialOutputAction::getParams(), NearestNodeDistanceAux::NearestNodeDistanceAux(), and NearestNodeValueAux::NearestNodeValueAux().

◆ boundaryRestricted()

bool BoundaryRestrictable::boundaryRestricted ( ) const

virtual

Returns true if this object has been restricted to a boundary.

See also: MooseObject

Definition at line 188 of file BoundaryRestrictable.C.

 {
   return BoundaryRestrictable::restricted(_bnd_ids);
 }

Referenced by MaterialOutputAction::getParams(), and DerivativeMaterialInterface< Material >::haveMaterialProperty().

◆ hasBoundary() [1/5]

bool BoundaryRestrictable::hasBoundary ( const BoundaryID & id ) const

Test if the supplied boundary ids are valid for this object.

Parameters

id	A BoundaryID to check

Returns: True if the given id is valid for this object

Definition at line 214 of file BoundaryRestrictable.C.

 {
   if (_bnd_ids.empty() || _bnd_ids.find(Moose::ANY_BOUNDARY_ID) != _bnd_ids.end())
     return true;
   else
     return _bnd_ids.find(id) != _bnd_ids.end();
 }

◆ hasBoundary() [2/5]

bool BoundaryRestrictable::hasBoundary ( const BoundaryName & name ) const

Test if the supplied boundary name is valid for this object.

Parameters

name	A BoundaryName to check

Returns: True if the given id is valid for this object

Definition at line 200 of file BoundaryRestrictable.C.

 {
   // Create a vector and utilize the getBoundaryIDs function, which
   // handles the ANY_BOUNDARY_ID (getBoundaryID does not)
   return hasBoundary(_bnd_mesh->getBoundaryIDs({name}));
 }

Referenced by hasBoundary(), and hasBoundaryMaterialPropertyHelper().

◆ hasBoundary() [3/5]

bool BoundaryRestrictable::hasBoundary	(	const std::set< BoundaryID > &	ids,
		TEST_TYPE	type = `ALL`
	)		const

Test if the supplied set of boundary ids are valid for this object.

Parameters

ids	A std::set of BoundaryIDs to check
type	A flag for the type of matching to perform: ALL requires that all supplied ids must match those of the object; ANY requires that any one of the supplied ids must match those of the object

Returns: True if the all of the given ids are found within the ids for this object

See also: isSubset

Definition at line 230 of file BoundaryRestrictable.C.

 {
   // An empty input is assumed to be ANY_BOUNDARY_ID
   if (ids.empty() || ids.find(Moose::ANY_BOUNDARY_ID) != ids.end())
     return true;
  
   // All supplied IDs must match those of the object
   else if (type == ALL)
   {
     if (_bnd_ids.find(Moose::ANY_BOUNDARY_ID) != _bnd_ids.end())
       return true;
     else
       return std::includes(_bnd_ids.begin(), _bnd_ids.end(), ids.begin(), ids.end());
   }
   // Any of the supplied IDs must match those of the object
   else
   {
     // Loop through the supplied ids
     for (const auto & id : ids)
     {
       // Test the current supplied id
       bool test = hasBoundary(id);
  
       // If the id exists in the stored ids, then return true, otherwise
       if (test)
         return true;
     }
     return false;
   }
 }

◆ hasBoundary() [4/5]

bool BoundaryRestrictable::hasBoundary	(	const std::vector< BoundaryID > &	ids,
		TEST_TYPE	type = `ALL`
	)		const

Test if the supplied vector boundary ids are valid for this object.

Parameters

ids	A vector of BoundaryIDs ids to check
type	A flag for the type of matching to perform: ALL requires that all supplied ids must match those of the object; ANY requires that any one of the supplied ids must match those of the object

Returns: True if the all of the given ids are found within the ids for this object

Definition at line 223 of file BoundaryRestrictable.C.

 {
   std::set<BoundaryID> ids_set(ids.begin(), ids.end());
   return hasBoundary(ids_set, type);
 }

◆ hasBoundary() [5/5]

bool BoundaryRestrictable::hasBoundary ( const std::vector< BoundaryName > & names ) const

Test if the supplied vector of boundary names are valid for this object.

Parameters

names A vector of BoundaryNames to check

Returns: True if the given ids are valid for this object

Definition at line 208 of file BoundaryRestrictable.C.

 {
   return hasBoundary(_bnd_mesh->getBoundaryIDs(names));
 }

◆ hasBoundaryMaterialProperty()

template<typename T >

bool BoundaryRestrictable::hasBoundaryMaterialProperty ( const std::string & prop_name ) const

Check if a material property is valid for all boundaries of this object.

This method returns true if the supplied property name has been declared in a Material object on the boundary ids for this object.

Template Parameters

T	The type of material property

Parameters

prop_name the name of the property to query

Returns: true if the property exists for all boundary ids of the object, otherwise false

Definition at line 224 of file BoundaryRestrictable.h.

 {
   // If you get here the supplied property is defined on all boundaries, but is still subject
   // existence in the MateialData class
   return hasBoundaryMaterialPropertyHelper(prop_name) &&
          _bnd_material_data->haveProperty<T>(prop_name);
 }

◆ hasBoundaryMaterialPropertyHelper()

bool BoundaryRestrictable::hasBoundaryMaterialPropertyHelper ( const std::string & prop_name ) const

protected

A helper method to avoid circular #include problems.

See also: hasBoundaryMaterialProperty

Definition at line 291 of file BoundaryRestrictable.C.

 {
   // Reference to MaterialWarehouse for testing and retrieving boundary ids
   const MaterialWarehouse & warehouse = _bnd_feproblem->getMaterialWarehouse();
  
   // Complete set of BoundaryIDs that this object is defined
   const std::set<BoundaryID> & ids =
       hasBoundary(Moose::ANY_BOUNDARY_ID) ? meshBoundaryIDs() : boundaryIDs();
  
   // Loop over each BoundaryID for this object
   for (const auto & id : ids)
   {
     // Storage of material properties that have been DECLARED on this BoundaryID
     std::set<std::string> declared_props;
  
     // If boundary materials exist, populated the set of properties that were declared
     if (warehouse.hasActiveBoundaryObjects(id))
     {
       const std::vector<std::shared_ptr<MaterialBase>> & mats =
           warehouse.getActiveBoundaryObjects(id);
       for (const auto & mat : mats)
       {
         const std::set<std::string> & mat_props = mat->getSuppliedItems();
         declared_props.insert(mat_props.begin(), mat_props.end());
       }
     }
  
     // If the supplied property is not in the list of properties on the current id, return false
     if (declared_props.find(prop_name) == declared_props.end())
       return false;
   }
  
   // If you get here the supplied property is defined on all boundaries
   return true;
 }

Referenced by hasBoundaryMaterialProperty().

◆ initializeBoundaryRestrictable()

void BoundaryRestrictable::initializeBoundaryRestrictable ( const MooseObject * moose_object )

private

An initialization routine needed for dual constructors.

Definition at line 76 of file BoundaryRestrictable.C.

 {
   // The name and id of the object
   const std::string & name = moose_object->getParamTempl<std::string>("_object_name");
  
   // If the mesh pointer is not defined, but FEProblemBase is, get it from there
   if (_bnd_feproblem != NULL && _bnd_mesh == NULL)
     _bnd_mesh = &_bnd_feproblem->mesh();
  
   // Check that the mesh pointer was defined, it is required for this class to operate
   if (_bnd_mesh == NULL)
     mooseError("The input parameters must contain a pointer to FEProblemBase via '_fe_problem' or "
                "a pointer to the MooseMesh via '_mesh'");
  
   // If the user supplies boundary IDs
   if (moose_object->isParamValid("boundary"))
   {
     // Extract the blocks from the input
     _boundary_names = moose_object->getParamTempl<std::vector<BoundaryName>>("boundary");
  
     // Get the IDs from the supplied names
     std::vector<BoundaryID> vec_ids = _bnd_mesh->getBoundaryIDs(_boundary_names, true);
  
     // Store the IDs, handling ANY_BOUNDARY_ID if supplied
     if (std::find(_boundary_names.begin(), _boundary_names.end(), "ANY_BOUNDARY_ID") !=
         _boundary_names.end())
       _bnd_ids.insert(Moose::ANY_BOUNDARY_ID);
     else
       _bnd_ids.insert(vec_ids.begin(), vec_ids.end());
   }
  
   // Produce error if the object is not allowed to be both block and boundary restricted
   if (!_bnd_dual_restrictable && !_bnd_ids.empty() && !_block_ids.empty())
     if (!_block_ids.empty() && _block_ids.find(Moose::ANY_BLOCK_ID) == _block_ids.end())
       moose_object->paramError("boundary",
                                "Attempted to restrict the object '",
                                name,
                                "' to a boundary, but the object is already restricted by block(s)");
  
   // Store ANY_BOUNDARY_ID if empty
   if (_bnd_ids.empty())
   {
     _bnd_ids.insert(Moose::ANY_BOUNDARY_ID);
     _boundary_names = {"ANY_BOUNDARY_ID"};
   }
  
   // If this object is block restricted, check that defined blocks exist on the mesh
   if (_bnd_ids.find(Moose::ANY_BOUNDARY_ID) == _bnd_ids.end())
   {
     const std::set<BoundaryID> * valid_ids;
     const char * message_ptr = nullptr;
  
     if (_bnd_nodal)
     {
       valid_ids = &_bnd_mesh->meshNodesetIds();
       message_ptr = "node set";
     }
     else
     {
       valid_ids = &_bnd_mesh->meshSidesetIds();
       message_ptr = "side set";
     }
  
     std::vector<BoundaryID> diff;
  
     std::set_difference(_bnd_ids.begin(),
                         _bnd_ids.end(),
                         valid_ids->begin(),
                         valid_ids->end(),
                         std::back_inserter(diff));
  
     if (!diff.empty())
     {
       std::ostringstream msg;
       msg << "the following " << message_ptr << " ids do not exist on the mesh:";
       for (const auto & id : diff)
         msg << " " << id;
  
       if (!_bnd_nodal)
         // Diagnostic message
         msg << "\n\nMOOSE distinguishes between \"node sets\" and \"side sets\" depending on "
                "whether \nyou are using \"Nodal\" or \"Integrated\" BCs respectively. Node sets "
                "corresponding \nto your side sets are constructed for you by default.\n\n"
                "Try setting \"Mesh/construct_side_set_from_node_set=true\" if you see this error.\n"
                "Note: If you are running with adaptivity you should prefer using side sets.";
  
       moose_object->paramError("boundary", msg.str());
     }
   }
 }

Referenced by BoundaryRestrictable().

◆ isBoundarySubset() [1/2]

bool BoundaryRestrictable::isBoundarySubset ( const std::set< BoundaryID > & ids ) const

Test if the class boundary ids are a subset of the supplied objects.

Parameters

ids	A std::set of boundaries to check

Returns: True if all of the boundary ids for this class are found within the given ids (opposite of hasBoundary)

See also: hasBoundary

Definition at line 262 of file BoundaryRestrictable.C.

 {
   // An empty input is assumed to be ANY_BOUNDARY_ID
   if (ids.empty() || ids.find(Moose::ANY_BOUNDARY_ID) != ids.end())
     return true;
  
   if (_bnd_ids.find(Moose::ANY_BOUNDARY_ID) != _bnd_ids.end())
     return std::includes(ids.begin(),
                          ids.end(),
                          _bnd_mesh->meshBoundaryIds().begin(),
                          _bnd_mesh->meshBoundaryIds().end());
   else
     return std::includes(ids.begin(), ids.end(), _bnd_ids.begin(), _bnd_ids.end());
 }

Referenced by isBoundarySubset().

◆ isBoundarySubset() [2/2]

bool BoundaryRestrictable::isBoundarySubset ( const std::vector< BoundaryID > & ids ) const

Definition at line 278 of file BoundaryRestrictable.C.

 {
   std::set<BoundaryID> ids_set(ids.begin(), ids.end());
   return isBoundarySubset(ids_set);
 }

◆ meshBoundaryIDs()

const std::set< BoundaryID > & BoundaryRestrictable::meshBoundaryIDs ( ) const

Returns the set of all boundary ids for the entire mesh.

Returns: A const reference the the boundary ids for the entire mesh

Definition at line 285 of file BoundaryRestrictable.C.

 {
   return _bnd_mesh->getBoundaryIDs();
 }

Referenced by hasBoundaryMaterialPropertyHelper().

◆ numBoundaryIDs()

unsigned int BoundaryRestrictable::numBoundaryIDs ( ) const

Return the number of boundaries for this object.

Returns: The number of boundary ids

Definition at line 182 of file BoundaryRestrictable.C.

 {
   return (unsigned int)_bnd_ids.size();
 }

Referenced by SidesetInfoVectorPostprocessor::initialize().

◆ restricted()

bool BoundaryRestrictable::restricted ( const std::set< BoundaryID > & ids )

static

Helper for determining if the object is boundary restricted.

This is needed for the MaterialPropertyInterface.

Definition at line 194 of file BoundaryRestrictable.C.

 {
   return ids.find(Moose::ANY_BOUNDARY_ID) == ids.end();
 }

Referenced by boundaryRestricted().

◆ validParams()

InputParameters BoundaryRestrictable::validParams ( )

static

Definition at line 19 of file BoundaryRestrictable.C.

 {
  
   // Create instance of InputParameters
   InputParameters params = emptyInputParameters();
  
   // Create user-facing 'boundary' input for restricting inheriting object to boundaries
   params.addParam<std::vector<BoundaryName>>(
       "boundary", "The list of boundary IDs from the mesh where this boundary condition applies");
  
   // A parameter for disabling error message for objects restrictable by boundary and block,
   // if the parameter is valid it was already set so don't do anything
   if (!params.isParamValid("_dual_restrictable"))
     params.addPrivateParam<bool>("_dual_restrictable", false);
  
   return params;
 }

Referenced by NodalUserObject::validParams(), InterfaceKernelBase::validParams(), InitialConditionBase::validParams(), DGKernelBase::validParams(), MaterialBase::validParams(), NodalKernel::validParams(), and AuxKernelTempl< ComputeValueType >::validParams().

Member Data Documentation

◆ _block_ids

const std::set<SubdomainID>& BoundaryRestrictable::_block_ids

private

Reference to the block_ids, defaults to an empty set if not provided.

Definition at line 198 of file BoundaryRestrictable.h.

Referenced by initializeBoundaryRestrictable().

◆ _bnd_dual_restrictable

const bool BoundaryRestrictable::_bnd_dual_restrictable

private

Flag for allowing dual restriction with BlockRestrictable.

Definition at line 192 of file BoundaryRestrictable.h.

Referenced by initializeBoundaryRestrictable().

◆ _bnd_feproblem

FEProblemBase* BoundaryRestrictable::_bnd_feproblem

private

Pointer to FEProblemBase.

Definition at line 180 of file BoundaryRestrictable.h.

Referenced by hasBoundaryMaterialPropertyHelper(), and initializeBoundaryRestrictable().

◆ _bnd_ids

std::set<BoundaryID> BoundaryRestrictable::_bnd_ids

private

Set of the boundary ids.

Definition at line 186 of file BoundaryRestrictable.h.

Referenced by boundaryIDs(), boundaryRestricted(), hasBoundary(), initializeBoundaryRestrictable(), isBoundarySubset(), and numBoundaryIDs().

◆ _bnd_material_data

std::shared_ptr<MaterialData> BoundaryRestrictable::_bnd_material_data

private

Pointer to MaterialData for boundary (.

See also: hasBoundaryMaterialProperty)

Definition at line 204 of file BoundaryRestrictable.h.

Referenced by hasBoundaryMaterialProperty().

◆ _bnd_mesh

MooseMesh* BoundaryRestrictable::_bnd_mesh

private

Point to mesh.

Definition at line 183 of file BoundaryRestrictable.h.

Referenced by hasBoundary(), initializeBoundaryRestrictable(), isBoundarySubset(), and meshBoundaryIDs().

◆ _bnd_nodal

bool BoundaryRestrictable::_bnd_nodal

private

Whether or not this object is restricted to nodesets.

Definition at line 207 of file BoundaryRestrictable.h.

Referenced by initializeBoundaryRestrictable().

◆ _bnd_tid

THREAD_ID BoundaryRestrictable::_bnd_tid

private

Thread id for this object.

Definition at line 201 of file BoundaryRestrictable.h.

◆ _boundary_names

std::vector<BoundaryName> BoundaryRestrictable::_boundary_names

private

Vector the the boundary names.

Definition at line 189 of file BoundaryRestrictable.h.

Referenced by boundaryNames(), and initializeBoundaryRestrictable().

◆ _empty_block_ids

const std::set<SubdomainID> BoundaryRestrictable::_empty_block_ids

private

An empty set for referencing when block_ids is not included.

Definition at line 195 of file BoundaryRestrictable.h.

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

include/interfaces/BoundaryRestrictable.h
src/interfaces/BoundaryRestrictable.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ TEST_TYPE

Constructor & Destructor Documentation

◆ BoundaryRestrictable() [1/2]

◆ BoundaryRestrictable() [2/2]

◆ ~BoundaryRestrictable()

Member Function Documentation

◆ boundaryIDs()

◆ boundaryNames()

◆ boundaryRestricted()

◆ hasBoundary() [1/5]

◆ hasBoundary() [2/5]

◆ hasBoundary() [3/5]

◆ hasBoundary() [4/5]

◆ hasBoundary() [5/5]

◆ hasBoundaryMaterialProperty()

◆ hasBoundaryMaterialPropertyHelper()

◆ initializeBoundaryRestrictable()

◆ isBoundarySubset() [1/2]

◆ isBoundarySubset() [2/2]

◆ meshBoundaryIDs()

◆ numBoundaryIDs()

◆ restricted()

◆ validParams()

Member Data Documentation

◆ _block_ids

◆ _bnd_dual_restrictable

◆ _bnd_feproblem

◆ _bnd_ids

◆ _bnd_material_data

◆ _bnd_mesh

◆ _bnd_nodal

◆ _bnd_tid

◆ _boundary_names

◆ _empty_block_ids