BlockRestrictable Class Reference

An interface that restricts an object to subdomains via the 'blocks' input parameter. More...

#include <BlockRestrictable.h>

Inheritance diagram for BlockRestrictable:

Public Member Functions
	BlockRestrictable (const MooseObject *moose_object, bool initialize=true)
	Class constructor Populates the 'block' input parameters, see the general class documentation for details. More...
	BlockRestrictable (const MooseObject *moose_object, const std::set< BoundaryID > &boundary_ids)
	Class constructor Populates the 'block' input parameters when an object is also boundary restricted, see the general class documentation for details. More...
virtual	~BlockRestrictable ()
	Destructor: does nothing but needs to be marked as virtual since this class defines virtual functions. More...
const std::vector< SubdomainName > &	blocks () const
	Return the block names for this object. More...
unsigned int	numBlocks () const
	Return the number of blocks for this object. More...
virtual const std::set< SubdomainID > &	blockIDs () const
	Return the block subdomain ids for this object Note, if this is not block restricted, this function returns all mesh subdomain ids. More...
unsigned int	blocksMaxDimension () const
	Return the largest mesh dimension of the elements in the blocks for this object. More...
bool	hasBlocks (const SubdomainName &name) const
	Test if the supplied block name is valid for this object. More...
bool	hasBlocks (const std::vector< SubdomainName > &names) const
	Test if the supplied vector of block names are valid for this object. More...
bool	hasBlocks (const std::set< SubdomainName > &names) const
	Test if the supplied set of block names are valid for this object. More...
bool	hasBlocks (SubdomainID id) const
	Test if the supplied block ids are valid for this object. More...
bool	hasBlocks (const std::vector< SubdomainID > &ids) const
	Test if the supplied vector block ids are valid for this object. More...
bool	hasBlocks (const std::set< SubdomainID > &ids) const
	Test if the supplied set of block ids are valid for this object. More...
bool	isBlockSubset (const std::set< SubdomainID > &ids) const
	Test if the class block ids are a subset of the supplied objects. More...
bool	isBlockSubset (const std::vector< SubdomainID > &ids) const
	Test if the class block ids are a subset of the supplied objects. More...
template<typename T , bool is_ad = false>
bool	hasBlockMaterialProperty (const std::string &prop_name)
	Check if a material property is valid for all blocks of this object. More...
const std::set< SubdomainID > &	meshBlockIDs () const
	Return all of the SubdomainIDs for the mesh. More...
virtual bool	blockRestricted () const
	Returns true if this object has been restricted to a block. More...
virtual void	checkVariable (const MooseVariableFieldBase &variable) const
	Helper for checking that the ids for this object are in agreement with the variables on the supplied variable. More...

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual bool	hasBlockMaterialPropertyHelper (const std::string &prop_name)
	A helper method to allow the Material object to specialize the behavior of hasBlockMaterialProperty. More...
void	initializeBlockRestrictable (const MooseObject *moose_object)
	An initialization routine needed for dual constructors. More...
Moose::CoordinateSystemType	getBlockCoordSystem ()
	Check if the blocks this object operates on all have the same coordinate system, and if so return it. More...

Protected Attributes
const MaterialData *	_blk_material_data
	Pointer to the MaterialData class for this object. More...

Private Attributes
std::set< SubdomainID >	_blk_ids
	Set of block ids supplied by the user via the input file (for error checking) More...
std::vector< SubdomainID >	_vec_ids
	Vector of block ids supplied by the user via the input file (for error reporting) More...
std::vector< SubdomainName >	_blocks
	Vector the block names supplied by the user via the input file. More...
const bool	_blk_dual_restrictable
	Flag for allowing dual restriction. More...
FEProblemBase *	_blk_feproblem
	Pointer to FEProblemBase. More...
const MooseMesh *	_blk_mesh
	Pointer to Mesh. More...
const std::set< BoundaryID >	_empty_boundary_ids
	An empty set for referencing when boundary_ids is not included. More...
const std::set< BoundaryID > &	_boundary_ids
	Reference to the boundary_ids, defaults to an empty set if not provided. More...
THREAD_ID	_blk_tid
	Thread id for this object. More...
const std::string &	_blk_name
	Name of the object. More...
unsigned int	_blk_dim
	Largest mesh dimension of the elements in the blocks for this object. More...

Detailed Description

An interface that restricts an object to subdomains via the 'blocks' input parameter.

This class adds the 'blocks' input parameter and checks that it is populated, if it is not populated it will be populated with all valid block ids via two methods:

1. If a 'variable' parameter is present in the input parameters then by default the 'block' input is set to all blocks associated with the variable.
2. If no 'variable' parameter is present then it utilizes all available blocks for the associated mesh.

When using with an object with a 'variable' parameter (e.g., Kernel), the following must also exist within the input parameters for the class to operate correctly

• '_fe_problem' = pointer to FEProblemBase
• '_tid' = THREAD_ID for the class
• '_sys' = pointer to the SystemBase

In the general case (i.e., no 'variable') either one of the following must also exist within the input parameters for proper operation of the class:

• '_fe_problem' = a pointer to FEProblemBase
• '_mesh' = a pointer to MooseMesh

When creating a new object, generally, this class should be inherited following MooseObject. Also, the BlockRestricted::validParams() must be added to any other parameters for the the class being created, since this is where the 'blocks' input parameter is created.

See also

Kernel

SideSetsAroundSubdomain

Definition at line 57 of file BlockRestrictable.h.

Constructor & Destructor Documentation

BlockRestrictable() [1/2]

BlockRestrictable::BlockRestrictable	(	const MooseObject *	moose_object,
		bool	initialize = true
	)

Class constructor Populates the 'block' input parameters, see the general class documentation for details.

Parameters

parameters	The input parameters (see the detailed help for additional information)
initialize	Disable initialization, MooseVariableBase was converted to a MooseObject, this flag allows it to be constructed as if it wasn't to maintain backward compatibility, this will be removed in the fugure. TODO:MooseVariableToMooseObject (see #10601)

Definition at line 40 of file BlockRestrictable.C.

  : _blk_dual_restrictable(moose_object->getParam<bool>("_dual_restrictable")),
    _blk_feproblem(moose_object->isParamValid("_fe_problem_base")
                       ? moose_object->getParam<FEProblemBase *>("_fe_problem_base")
                       : NULL),
    _blk_mesh(moose_object->isParamValid("_mesh") ? moose_object->getParam<MooseMesh *>("_mesh")
                                                  : NULL),
    _boundary_ids(_empty_boundary_ids),
    _blk_tid(moose_object->isParamValid("_tid") ? moose_object->getParam<THREAD_ID>("_tid") : 0),
    _blk_name(moose_object->getParam<std::string>("_object_name")),
    _blk_dim(libMesh::invalid_uint)
{
  if (initialize)
    initializeBlockRestrictable(moose_object);
}

BlockRestrictable() [2/2]

BlockRestrictable::BlockRestrictable	(	const MooseObject *	moose_object,
		const std::set< BoundaryID > &	boundary_ids
	)

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

Parameters

parameters	The input parameters (see the detailed help for additional information)
boundary_ids	The boundary ids that the object is restricted to

Definition at line 57 of file BlockRestrictable.C.

  : _blk_dual_restrictable(moose_object->getParam<bool>("_dual_restrictable")),
    _blk_feproblem(moose_object->isParamValid("_fe_problem_base")
                       ? moose_object->getParam<FEProblemBase *>("_fe_problem_base")
                       : NULL),
    _blk_mesh(moose_object->isParamValid("_mesh") ? moose_object->getParam<MooseMesh *>("_mesh")
                                                  : NULL),
    _boundary_ids(boundary_ids),
    _blk_tid(moose_object->isParamValid("_tid") ? moose_object->getParam<THREAD_ID>("_tid") : 0),
    _blk_name(moose_object->getParam<std::string>("_object_name")),
    _blk_dim(libMesh::invalid_uint)
{
  initializeBlockRestrictable(moose_object);
}

~BlockRestrictable()

virtual BlockRestrictable::~BlockRestrictable ( )

inlinevirtual

Destructor: does nothing but needs to be marked as virtual since this class defines virtual functions.

Definition at line 86 of file BlockRestrictable.h.

{}

Member Function Documentation

blockIDs()

const std::set< SubdomainID > & BlockRestrictable::blockIDs ( ) const

virtual

Return the block subdomain ids for this object Note, if this is not block restricted, this function returns all mesh subdomain ids.

Returns

a set of SubdomainIDs that are valid for this object

Definition at line 194 of file BlockRestrictable.C.

Referenced by FunctorMaterial::addFunctorProperty(), DiracKernelBase::addPoint(), DiracKernelBase::addPointWithValidId(), NodalPatchRecoveryAuxBase::blockRestrictElements(), ComboMarker::ComboMarker(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), getBlockCoordSystem(), MaterialBase::getGenericZeroMaterialPropertyByName(), FunctorIC::gradient(), hasBlockMaterialPropertyHelper(), IndicatorMarker::IndicatorMarker(), SubdomainsDivision::initialize(), ElementCentroidPositions::initialize(), QuadraturePointsPositions::initialize(), FunctorExtremaPositions::initialize(), MooseVariableBase::MooseVariableBase(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), MaterialBase::registerPropName(), FVPointValueConstraint::setMyElem(), and FunctorIC::value().

{
  if (_blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
    return _blk_mesh->meshSubdomains();
  else
    return _blk_ids;
}

blockRestricted()

bool BlockRestrictable::blockRestricted ( ) const

virtual

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

See also

MooseObject

Definition at line 182 of file BlockRestrictable.C.

Referenced by NodalPatchRecoveryAuxBase::blockRestrictElements(), checkVariable(), SubdomainsDivision::divisionIndex(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), getBlockCoordSystem(), FunctorIC::gradient(), hasBlockMaterialPropertyHelper(), SubdomainsDivision::initialize(), ElementCentroidPositions::initialize(), QuadraturePointsPositions::initialize(), initializeBlockRestrictable(), SolutionIC::initialSetup(), MooseVariableBase::MooseVariableBase(), FVPointValueConstraint::setMyElem(), and FunctorIC::value().

{
  return _blk_ids.find(Moose::ANY_BLOCK_ID) == _blk_ids.end();
}

blocks()

const std::vector< SubdomainName > & BlockRestrictable::blocks

(

)

const

Return the block names for this object.

Note, if the 'blocks' input parameter was not utilized this will return an empty vector.

Returns

vector of SubdomainNames that are valid for this object

Definition at line 188 of file BlockRestrictable.C.

Referenced by MaterialOutputAction::getParams(), SubdomainsDivision::initialize(), and SolutionIC::initialSetup().

{
  return _blocks;
}

blocksMaxDimension()

unsigned int BlockRestrictable::blocksMaxDimension

(

)

const

Return the largest mesh dimension of the elements in the blocks for this object.

Definition at line 371 of file BlockRestrictable.C.

{
  mooseAssert(_blk_dim != libMesh::invalid_uint, "Block restriction not initialized");
  return _blk_dim;
}

checkVariable()

void BlockRestrictable::checkVariable ( const MooseVariableFieldBase &  variable ) const

virtual

Helper for checking that the ids for this object are in agreement with the variables on the supplied variable.

Parameters

variable

The variable to check against.

Reimplemented in DomainUserObject.

Definition at line 343 of file BlockRestrictable.C.

Referenced by DomainUserObject::checkVariable().

{
  // a variable defined on all internal sides does not need this check because
  // it can be coupled with other variables in DG kernels
  if (!_blk_mesh->interiorLowerDBlocks().empty() &&
      variable.activeOnSubdomains(_blk_mesh->interiorLowerDBlocks()))
    return;

  if (!isBlockSubset(variable.activeSubdomains()))
  {
    std::string var_ids = Moose::stringify(variable.activeSubdomains(), ", ");
    std::string obj_ids = Moose::stringify(blockRestricted() ? _blk_ids : meshBlockIDs(), ", ");
    mooseError("The 'block' parameter of the object '",
               _blk_name,
               "' must be a subset of the 'block' parameter of the variable '",
               variable.name(),
               "':\n    Object '",
               _blk_name,
               "': ",
               obj_ids,
               "\n    Variable '",
               variable.name(),
               "': ",
               var_ids);
  }
}

getBlockCoordSystem()

Moose::CoordinateSystemType BlockRestrictable::getBlockCoordSystem ( )

protected

Check if the blocks this object operates on all have the same coordinate system, and if so return it.

Definition at line 321 of file BlockRestrictable.C.

{
  if (!_blk_mesh)
    mooseError("No mesh available in BlockRestrictable::checkCoordSystem()");
  if (!_blk_feproblem)
    mooseError("No problem available in BlockRestrictable::checkCoordSystem()");

  const auto & subdomains = blockRestricted() ? blockIDs() : meshBlockIDs();

  if (subdomains.empty())
    mooseError("No subdomains found in the problem.");

  // make sure all subdomains are using the same coordinate system
  auto coord_system = _blk_feproblem->getCoordSystem(*subdomains.begin());
  for (auto subdomain : subdomains)
    if (_blk_feproblem->getCoordSystem(subdomain) != coord_system)
      mooseError("This object requires all subdomains to have the same coordinate system.");

  return coord_system;
}

hasBlockMaterialProperty()

template<typename T , bool is_ad>

bool BlockRestrictable::hasBlockMaterialProperty

(

const std::string &

prop_name

)

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

This method returns true if the supplied property name has been declared in a Material object on the block 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 block ids of the object, otherwise false

See also

Material::hasBlockMaterialProperty

Definition at line 271 of file BlockRestrictable.h.

{
  mooseAssert(_blk_material_data != NULL, "MaterialData pointer is not defined");
  return hasBlockMaterialPropertyHelper(prop_name) &&
         _blk_material_data->haveGenericProperty<T, is_ad>(prop_name);
}

hasBlockMaterialPropertyHelper()

bool BlockRestrictable::hasBlockMaterialPropertyHelper ( const std::string &  prop_name )

protectedvirtual

A helper method to allow the Material object to specialize the behavior of hasBlockMaterialProperty.

It also avoid circular #include problems.

See also

hasBlockMaterialProperty

Definition at line 285 of file BlockRestrictable.C.

Referenced by hasBlockMaterialProperty().

{

  // Reference to MaterialWarehouse for testing and retrieving block ids
  const MaterialWarehouse & warehouse = _blk_feproblem->getMaterialWarehouse();

  // Complete set of ids that this object is active
  const std::set<SubdomainID> & ids = blockRestricted() ? blockIDs() : meshBlockIDs();

  // Loop over each id for this object
  for (const auto & id : ids)
  {
    // Storage of material properties that have been DECLARED on this id
    std::set<std::string> declared_props;

    // If block materials exist, populated the set of properties that were declared
    if (warehouse.hasActiveBlockObjects(id))
    {
      const std::vector<std::shared_ptr<MaterialBase>> & mats = warehouse.getActiveBlockObjects(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 blocks
  return true;
}

hasBlocks() [1/6]

bool BlockRestrictable::hasBlocks

(

const SubdomainName &

name

)

const

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

Parameters

name	A SubdomainName to check

Returns

True if the given id is valid for this object

Definition at line 209 of file BlockRestrictable.C.

Referenced by LinearFVFluxKernel::addMatrixContribution(), DiracKernelBase::addPoint(), LinearFVFluxKernel::addRightHandSideContribution(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), DomainUserObject::checkVariable(), ComputeJacobianThread::compute(), ComboMarker::computeElementMarker(), GradientJumpIndicator::computeQpIntegral(), ProjectionAux::computeValue(), DomainUserObject::DomainUserObject(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), ExtraIDIntegralVectorPostprocessor::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MeshDivisionFunctorReductionVectorPostprocessor::hasBlocks(), hasBlocks(), MooseVariableField< Real >::hasBlocks(), FVFluxKernel::hasFaceSide(), IndicatorMarker::IndicatorMarker(), UpdateErrorVectorsThread::onElement(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), and BlockRestrictionDebugOutput::printBlockRestrictionMap().

{
  // Create a vector and utilize the getSubdomainIDs function, which
  // handles the ANY_BLOCK_ID (getSubdomainID does not)
  std::vector<SubdomainName> names(1);
  names[0] = name;
  return hasBlocks(_blk_mesh->getSubdomainIDs(names));
}

hasBlocks() [2/6]

bool BlockRestrictable::hasBlocks

(

const std::vector< SubdomainName > &

names

)

const

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

Parameters

names

A vector of SubdomainNames to check

Returns

True if the given ids are valid for this object

Definition at line 219 of file BlockRestrictable.C.

{
  return hasBlocks(_blk_mesh->getSubdomainIDs(names));
}

hasBlocks() [3/6]

bool BlockRestrictable::hasBlocks

(

const std::set< SubdomainName > &

names

)

const

Test if the supplied set of block names are valid for this object.

Parameters

names

A set of SubdomainNames to check

Returns

True if the given ids are valid for this object

Definition at line 225 of file BlockRestrictable.C.

{
  return hasBlocks(_blk_mesh->getSubdomainIDs(names));
}

hasBlocks() [4/6]

bool BlockRestrictable::hasBlocks

(

SubdomainID

id

)

const

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

Parameters

id	A SubdomainID to check

Returns

True if the given id is valid for this object

Definition at line 231 of file BlockRestrictable.C.

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

hasBlocks() [5/6]

bool BlockRestrictable::hasBlocks

(

const std::vector< SubdomainID > &

ids

)

const

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

Parameters

ids	A vector of SubdomainIDs ids to check

Returns

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

Definition at line 240 of file BlockRestrictable.C.

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

hasBlocks() [6/6]

bool BlockRestrictable::hasBlocks

(

const std::set< SubdomainID > &

ids

)

const

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

Parameters

ids	A std::set of SubdomainIDs to check

Returns

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

See also

isSubset

Definition at line 247 of file BlockRestrictable.C.

{
  if (_blk_ids.empty() || _blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
    return true;
  else
    return std::includes(_blk_ids.begin(), _blk_ids.end(), ids.begin(), ids.end());
}

initializeBlockRestrictable()

void BlockRestrictable::initializeBlockRestrictable ( const MooseObject *  moose_object )

protected

An initialization routine needed for dual constructors.

Definition at line 74 of file BlockRestrictable.C.

Referenced by BlockRestrictable().

{
  // If the mesh pointer is not defined, but FEProblemBase is, get it from there
  if (_blk_feproblem != NULL && _blk_mesh == NULL)
    _blk_mesh = &_blk_feproblem->mesh();

  // Check that the mesh pointer was defined, it is required for this class to operate
  if (_blk_mesh == NULL)
    mooseError("The input parameters must contain a pointer to FEProblem via '_fe_problem' or a "
               "pointer to the MooseMesh via '_mesh'");

  // Populate the MaterialData pointer
  if (_blk_feproblem != NULL)
    _blk_material_data = &_blk_feproblem->getMaterialData(Moose::BLOCK_MATERIAL_DATA, _blk_tid);

  // The 'block' input is defined
  if (moose_object->isParamValid("block"))
  {
    // Extract the blocks from the input
    _blocks = moose_object->getParam<std::vector<SubdomainName>>("block");

    // Store the IDs in a set, handling ANY_BLOCK_ID if supplied
    if (std::find(_blocks.begin(), _blocks.end(), "ANY_BLOCK_ID") != _blocks.end())
      _blk_ids.insert(Moose::ANY_BLOCK_ID);
    else
    {
      // Get the IDs from the supplied names
      _vec_ids = _blk_mesh->getSubdomainIDs(_blocks);
      _blk_ids.insert(_vec_ids.begin(), _vec_ids.end());
    }
  }

  // When 'blocks' is not set and there is a "variable", use the blocks from the variable
  else if (moose_object->isParamValid("variable"))
  {
    std::string variable_name = moose_object->parameters().getMooseType("variable");
    if (!variable_name.empty())
      _blk_ids = _blk_feproblem
                     ->getVariable(_blk_tid,
                                   variable_name,
                                   Moose::VarKindType::VAR_ANY,
                                   Moose::VarFieldType::VAR_FIELD_ANY)
                     .activeSubdomains();
  }

  // Produce error if the object is not allowed to be both block and boundary restricted
  if (!_blk_dual_restrictable && !_boundary_ids.empty() && !_boundary_ids.empty())
    if (!_boundary_ids.empty() && _boundary_ids.find(Moose::ANY_BOUNDARY_ID) == _boundary_ids.end())
      moose_object->paramError("block",
                               "Attempted to restrict the object '",
                               _blk_name,
                               "' to a block, but the object is already restricted by boundary");

  // If no blocks were defined above, specify that it is valid on all blocks
  if (_blk_ids.empty() && !moose_object->isParamValid("boundary"))
  {
    _blk_ids.insert(Moose::ANY_BLOCK_ID);
    _blocks = {"ANY_BLOCK_ID"};
  }

  // If this object is block restricted, check that defined blocks exist on the mesh
  if (_blk_ids.find(Moose::ANY_BLOCK_ID) == _blk_ids.end())
  {
    const std::set<SubdomainID> & valid_ids = _blk_mesh->meshSubdomains();
    std::vector<SubdomainID> diff;

    std::set_difference(_blk_ids.begin(),
                        _blk_ids.end(),
                        valid_ids.begin(),
                        valid_ids.end(),
                        std::back_inserter(diff));

    if (!diff.empty())
    {
      std::ostringstream msg;
      auto sep = " ";
      msg << "the following blocks (ids) do not exist on the mesh:";
      for (const auto & id : diff)
      {
        if (_blk_name.size() > 0)
        {
          auto & name =
              _blocks.at(std::find(_vec_ids.begin(), _vec_ids.end(), id) - _vec_ids.begin());
          if (std::to_string(id) != name)
            msg << sep << name << " (" << id << ")";
          else
            msg << sep << id;
        }
        else
          msg << sep << id;
        sep = ", ";
      }
      std::vector<SubdomainID> valid_ids_vec(valid_ids.begin(), valid_ids.end());
      auto valid_names = _blk_mesh->getSubdomainNames(valid_ids_vec);
      msg << "\nBlocks names (resp. ids) that do exist: " << Moose::stringify(valid_names) << " ("
          << Moose::stringify(valid_ids) << ")";
      moose_object->paramError("block", msg.str());
    }
  }

  // Get the mesh dimension for the blocks
  if (blockRestricted())
    _blk_dim = _blk_mesh->getBlocksMaxDimension(_blocks);
  else
    _blk_dim = _blk_mesh->dimension();
}

isBlockSubset() [1/2]

bool BlockRestrictable::isBlockSubset

(

const std::set< SubdomainID > &

ids

)

const

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

Parameters

ids	A std::set of Subdomains to check

Returns

True if all of the block ids for this class are found within the given ids (opposite of hasBlocks)

See also

hasBlocks

Definition at line 256 of file BlockRestrictable.C.

Referenced by checkVariable(), isBlockSubset(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), and ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux().

{
  // An empty input is assumed to be ANY_BLOCK_ID
  if (ids.empty() || ids.find(Moose::ANY_BLOCK_ID) != ids.end())
    return true;

  if (_blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
    return std::includes(ids.begin(),
                         ids.end(),
                         _blk_mesh->meshSubdomains().begin(),
                         _blk_mesh->meshSubdomains().end());
  else
    return std::includes(ids.begin(), ids.end(), _blk_ids.begin(), _blk_ids.end());
}

isBlockSubset() [2/2]

bool BlockRestrictable::isBlockSubset

(

const std::vector< SubdomainID > &

ids

)

const

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

Parameters

ids	A std::vector of Subdomains to check

Returns

True if all of the block ids for this class are found within the given ids (opposite of hasBlocks)

See also

hasBlocks

Definition at line 272 of file BlockRestrictable.C.

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

meshBlockIDs()

const std::set< SubdomainID > & BlockRestrictable::meshBlockIDs

(

)

const

Return all of the SubdomainIDs for the mesh.

Returns

A set of all subdomians for the entire mesh

Definition at line 279 of file BlockRestrictable.C.

Referenced by checkVariable(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), getBlockCoordSystem(), hasBlockMaterialPropertyHelper(), and SolutionIC::initialSetup().

{
  return _blk_mesh->meshSubdomains();
}

numBlocks()

unsigned int BlockRestrictable::numBlocks

(

)

const

Return the number of blocks for this object.

Returns

The number of subdomains

Definition at line 203 of file BlockRestrictable.C.

Referenced by ElementCentroidPositions::initialize(), and QuadraturePointsPositions::initialize().

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

validParams()

InputParameters BlockRestrictable::validParams ( )

static

Definition at line 21 of file BlockRestrictable.C.

Referenced by SubdomainsDivision::validParams(), QuadraturePointMultiApp::validParams(), CentroidMultiApp::validParams(), ElementCentroidPositions::validParams(), ElementGroupCentroidPositions::validParams(), QuadraturePointsPositions::validParams(), FunctorExtremaPositions::validParams(), KernelBase::validParams(), ProjectedStatefulMaterialStorageAction::validParams(), DiracKernelBase::validParams(), LinearFVKernel::validParams(), InternalSideUserObject::validParams(), NodalUserObject::validParams(), NodalKernelBase::validParams(), ElementUserObject::validParams(), Indicator::validParams(), FVKernel::validParams(), MooseVariableBase::validParams(), LineMaterialSamplerBase< Real >::validParams(), DGKernelBase::validParams(), DomainUserObject::validParams(), FVInitialConditionBase::validParams(), Marker::validParams(), InitialConditionBase::validParams(), AuxKernelTempl< Real >::validParams(), and MaterialBase::validParams().

{
  // Create InputParameters object that will be appended to the parameters for the inheriting object
  InputParameters params = emptyInputParameters();

  // Add the user-facing 'block' input parameter
  params.addParam<std::vector<SubdomainName>>(
      "block", "The list of blocks (ids or names) that this object will be applied");

  // 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.have_parameter<bool>("_dual_restrictable"))
    params.addPrivateParam<bool>("_dual_restrictable", false);

  // Return the parameters
  return params;
}

Member Data Documentation

_blk_dim

unsigned int BlockRestrictable::_blk_dim

private

Largest mesh dimension of the elements in the blocks for this object.

Definition at line 266 of file BlockRestrictable.h.

Referenced by blocksMaxDimension(), and initializeBlockRestrictable().

_blk_dual_restrictable

const bool BlockRestrictable::_blk_dual_restrictable

private

Flag for allowing dual restriction.

Definition at line 245 of file BlockRestrictable.h.

Referenced by initializeBlockRestrictable().

_blk_feproblem

FEProblemBase* BlockRestrictable::_blk_feproblem

private

Pointer to FEProblemBase.

Definition at line 248 of file BlockRestrictable.h.

Referenced by getBlockCoordSystem(), hasBlockMaterialPropertyHelper(), and initializeBlockRestrictable().

_blk_ids

std::set<SubdomainID> BlockRestrictable::_blk_ids

private

Set of block ids supplied by the user via the input file (for error checking)

Definition at line 236 of file BlockRestrictable.h.

Referenced by blockIDs(), blockRestricted(), checkVariable(), hasBlocks(), initializeBlockRestrictable(), isBlockSubset(), and numBlocks().

_blk_material_data

const MaterialData* BlockRestrictable::_blk_material_data

protected

Pointer to the MaterialData class for this object.

Definition at line 214 of file BlockRestrictable.h.

Referenced by hasBlockMaterialProperty(), and initializeBlockRestrictable().

_blk_mesh

const MooseMesh* BlockRestrictable::_blk_mesh

private

Pointer to Mesh.

Definition at line 251 of file BlockRestrictable.h.

Referenced by blockIDs(), checkVariable(), getBlockCoordSystem(), hasBlocks(), initializeBlockRestrictable(), isBlockSubset(), and meshBlockIDs().

_blk_name

const std::string& BlockRestrictable::_blk_name

private

Name of the object.

Definition at line 263 of file BlockRestrictable.h.

Referenced by checkVariable(), and initializeBlockRestrictable().

_blk_tid

THREAD_ID BlockRestrictable::_blk_tid

private

Thread id for this object.

Definition at line 260 of file BlockRestrictable.h.

Referenced by initializeBlockRestrictable().

_blocks

std::vector<SubdomainName> BlockRestrictable::_blocks

private

Vector the block names supplied by the user via the input file.

Definition at line 242 of file BlockRestrictable.h.

Referenced by blocks(), and initializeBlockRestrictable().

_boundary_ids

const std::set<BoundaryID>& BlockRestrictable::_boundary_ids

private

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

Definition at line 257 of file BlockRestrictable.h.

Referenced by initializeBlockRestrictable().

_empty_boundary_ids

const std::set<BoundaryID> BlockRestrictable::_empty_boundary_ids

private

An empty set for referencing when boundary_ids is not included.

Definition at line 254 of file BlockRestrictable.h.

_vec_ids

std::vector<SubdomainID> BlockRestrictable::_vec_ids

private

Vector of block ids supplied by the user via the input file (for error reporting)

Definition at line 239 of file BlockRestrictable.h.

Referenced by initializeBlockRestrictable().

---

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

• include/interfaces/BlockRestrictable.h
• src/interfaces/BlockRestrictable.C