Warehouse for storing constraints. More...

#include <ConstraintWarehouse.h>

Inheritance diagram for ConstraintWarehouse:

Public Member Functions
	ConstraintWarehouse ()

void	addObject (std::shared_ptr< Constraint > object, THREAD_ID tid=0, bool recurse=true) override
	Add Constraint object to the warehouse. More...

void	subdomainsCovered (std::set< SubdomainID > &subdomains_covered, std::set< std::string > &unique_variables, THREAD_ID tid=0) const
	Update supplied subdomain and variable coverate containters. More...

void	updateActive (THREAD_ID tid=0) override
	Update the various active lists. More...

virtual void	residualEnd (THREAD_ID tid=0) const

bool	hasVariableObjects (unsigned int variable_id, THREAD_ID tid=0) const
	Checks for whether this warehouse has objects for a given variable. More...

unsigned int	size (THREAD_ID tid=0) const
	Return how many kernels we store in the current warehouse. More...

bool	hasObjectsForVariableAndBlocks (const VariableName &var_name, const std::set< SubdomainID > &blocks, std::set< SubdomainID > &blocks_covered, THREAD_ID tid) const
	Whether there are objects for this variable and the set of blocks passed. More...

std::set< SubdomainID >	getActiveBlocks (THREAD_ID tid=0) const
	Return a set of active SubdomainsIDs. More...

const std::vector< std::shared_ptr< Constraint > > &	getObjectsForVariable (const VariableName &var_name, THREAD_ID tid) const
	Getter for objects that have the 'variable' set to a particular variable Note that users should check whether there are objects using 'hasObjectsForVariable' before calling this routine, because it will throw if there are no objects for this variable. More...

void	sort (THREAD_ID tid=0)
	Sort the objects using the DependencyResolver. More...

THREAD_ID	numThreads () const
	Return the number of threads. More...

std::string	activeObjectsToFormattedString (THREAD_ID tid=0, const std::string &prefix="[DBG]") const
	Output the active content of the warehouse to a string, meant to be output to the console. More...


const std::vector< std::shared_ptr< NodalConstraint > > &	getActiveNodalConstraints () const
	Access methods for active objects. More...

const std::vector< std::shared_ptr< MortarConstraintBase > > &	getActiveMortarConstraints (const std::pair< BoundaryID, BoundaryID > &mortar_interface_key, bool displaced) const

const std::vector< std::shared_ptr< ElemElemConstraint > > &	getActiveElemElemConstraints (InterfaceID interface_id, bool displaced) const

const std::vector< std::shared_ptr< NodeFaceConstraint > > &	getActiveNodeFaceConstraints (BoundaryID boundary_id, bool displaced) const

const std::vector< std::shared_ptr< NodeElemConstraintBase > > &	getActiveNodeElemConstraints (SubdomainID secondary_id, SubdomainID primary_id, bool displaced) const


bool	hasActiveNodalConstraints () const
	Deterimine if active objects exist. More...

bool	hasActiveMortarConstraints (const std::pair< BoundaryID, BoundaryID > &mortar_interface_key, bool displaced) const

bool	hasActiveElemElemConstraints (const InterfaceID interface_id, bool displaced) const

bool	hasActiveNodeFaceConstraints (BoundaryID boundary_id, bool displaced) const

bool	hasActiveNodeElemConstraints (SubdomainID secondary_id, SubdomainID primary_id, bool displaced) const


virtual void	initialSetup (THREAD_ID tid=0) const
	Convenience methods for calling object setup methods. More...

virtual void	timestepSetup (THREAD_ID tid=0) const

virtual void	customSetup (const ExecFlagType &exec_type, THREAD_ID tid=0) const

virtual void	subdomainSetup (THREAD_ID tid=0) const

virtual void	subdomainSetup (SubdomainID id, THREAD_ID tid=0) const

virtual void	jacobianSetup (THREAD_ID tid=0) const

virtual void	residualSetup (THREAD_ID tid=0) const


bool	hasActiveVariableBlockObjects (unsigned int variable_id, SubdomainID block_id, THREAD_ID tid=0) const
	Methods for checking/getting variable kernels for a variable and SubdomainID. More...

const std::vector< std::shared_ptr< Constraint > > &	getActiveVariableBlockObjects (unsigned int variable_id, SubdomainID block_id, THREAD_ID tid=0) const


const std::vector< std::shared_ptr< Constraint > > &	getObjects (THREAD_ID tid=0) const
	Retrieve complete vector to the all/block/boundary restricted objects for a given thread. More...

const std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > &	getBlockObjects (THREAD_ID tid=0) const

const std::vector< std::shared_ptr< Constraint > > &	getBlockObjects (SubdomainID id, THREAD_ID tid=0) const

const std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > &	getBoundaryObjects (THREAD_ID tid=0) const

const std::vector< std::shared_ptr< Constraint > > &	getBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const


const std::vector< std::shared_ptr< Constraint > > &	getActiveObjects (THREAD_ID tid=0) const
	Retrieve complete vector to the active all/block/boundary restricted objects for a given thread. More...

const std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > &	getActiveBlockObjects (THREAD_ID tid=0) const

const std::vector< std::shared_ptr< Constraint > > &	getActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const

const std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > &	getActiveBoundaryObjects (THREAD_ID tid=0) const

const std::vector< std::shared_ptr< Constraint > > &	getActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const


bool	hasObjects (THREAD_ID tid=0) const
	Convenience functions for determining if objects exist. More...

bool	hasActiveObjects (THREAD_ID tid=0) const

bool	hasObjectsForVariable (const VariableName &var_name, THREAD_ID tid) const

bool	hasActiveBlockObjects (THREAD_ID tid=0) const

bool	hasActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const

bool	hasActiveBoundaryObjects (THREAD_ID tid=0) const

bool	hasActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const

bool	hasBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const


bool	hasActiveObject (const std::string &name, THREAD_ID tid=0) const
	Convenience functions for checking/getting specific objects. More...

std::shared_ptr< Constraint >	getObject (const std::string &name, THREAD_ID tid=0) const

std::shared_ptr< Constraint >	getActiveObject (const std::string &name, THREAD_ID tid=0) const


void	updateVariableDependency (std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
	Update variable dependency vector. More...

void	updateBlockVariableDependency (SubdomainID id, std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const

void	updateBoundaryVariableDependency (std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const

void	updateBoundaryVariableDependency (BoundaryID id, std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const


void	updateFEVariableCoupledVectorTagDependency (std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
	Update FE variable coupleable vector tag vector for all objects, block-restricted objects, and boundary-restricted objects. More...

void	updateBlockFEVariableCoupledVectorTagDependency (SubdomainID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const

void	updateBoundaryFEVariableCoupledVectorTagDependency (BoundaryID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const


void	updateMatPropDependency (std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
	Update material property dependency vector. More...

void	updateBlockMatPropDependency (SubdomainID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const

void	updateBoundaryMatPropDependency (std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const

void	updateBoundaryMatPropDependency (BoundaryID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const

Protected Member Functions
virtual void	updateMatPropDependencyHelper (std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< Constraint >> &objects, const bool producer_only) const
	Helper method for updating material property dependency vector. More...

void	checkThreadID (THREAD_ID tid) const
	Calls assert on thread id. More...

Static Protected Member Functions
static void	updateActiveHelper (std::vector< std::shared_ptr< Constraint >> &active, const std::vector< std::shared_ptr< Constraint >> &all)
	Helper method for updating active vectors. More...

static void	sortHelper (std::vector< std::shared_ptr< Constraint >> &objects)
	Helper method for sorting vectors of objects. More...

static void	updateVariableDependencyHelper (std::set< MooseVariableFieldBase * > &needed_moose_vars, const std::vector< std::shared_ptr< Constraint >> &objects)
	Helper method for updating variable dependency vector. More...

static void	updateFEVariableCoupledVectorTagDependencyHelper (std::set< TagID > &needed_fe_var_vector_tags, const std::vector< std::shared_ptr< Constraint >> &objects)
	Helper method for updating FE variable coupleable vector tag vector. More...

Protected Attributes
MooseObjectWarehouse< NodalConstraint >	_nodal_constraints
	NodalConstraint objects. More...

std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > >	_node_face_constraints
	NodeFaceConstraint objects (non-displaced) More...

std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > >	_displaced_node_face_constraints
	NodeFaceConstraint objects (displaced) More...

std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > >	_mortar_constraints
	Undisplaced MortarConstraints. More...

std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > >	_displaced_mortar_constraints
	Displaced MortarConstraints. More...

std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > >	_element_constraints
	ElemElemConstraints (non-displaced) More...

std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > >	_displaced_element_constraints
	ElemElemConstraints (displaced) More...

std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > >	_node_elem_constraints
	NodeElemConstraint objects. More...

std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > >	_displaced_node_elem_constraints
	NodeElemConstraint objects. More...

std::map< unsigned int, MooseObjectWarehouse< Constraint > >	_variable_objects
	Variable based storage. More...

const THREAD_ID	_num_threads
	Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) More...

std::vector< std::vector< std::shared_ptr< Constraint > > >	_all_objects
	Storage container for the ALL pointers (THREAD_ID on outer vector) More...

std::vector< std::vector< std::shared_ptr< Constraint > > >	_active_objects
	All active objects (THREAD_ID on outer vector) More...

std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > >	_all_block_objects

std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > >	_active_block_objects
	Active block restricted objects (THREAD_ID on outer vector) More...

std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > >	_all_boundary_objects

std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > >	_active_boundary_objects
	Active boundary restricted objects (THREAD_ID on outer vector) More...

std::vector< std::map< VariableName, std::vector< std::shared_ptr< Constraint > > > >	_all_variable_objects
	All objects with a certain variable selected, as the 'variable' parameter. More...

Detailed Description

Warehouse for storing constraints.

Definition at line 26 of file ConstraintWarehouse.h.

Constructor & Destructor Documentation

◆ ConstraintWarehouse()

ConstraintWarehouse::ConstraintWarehouse ( )

Definition at line 21 of file ConstraintWarehouse.C.

21 : MooseObjectWarehouse<Constraint>(/*threaded=*/false) {}

MooseObjectWarehouse< Constraint >

Member Function Documentation

◆ activeObjectsToFormattedString()

std::string MooseObjectWarehouseBase< Constraint >::activeObjectsToFormattedString	(	THREAD_ID	tid = `0`,
		const std::string &	prefix = `"[DBG]"`
	)		const

inherited

Output the active content of the warehouse to a string, meant to be output to the console.

Parameters

tid	the thread id
prefix	a string to prepend to the string

Definition at line 874 of file MooseObjectWarehouseBase.h.

 {
   std::vector<std::string> output;
   for (const auto & object : _active_objects[tid])
     output.push_back(object->name());
   return ConsoleUtils::formatString(MooseUtils::join(output, " "), prefix);
 }

◆ addObject()

void ConstraintWarehouse::addObject	(	std::shared_ptr< Constraint >	object,
		THREAD_ID	tid = `0`,
		bool	recurse = `true`
	)

overridevirtual

Add Constraint object to the warehouse.

Parameters

object	A std::shared_ptr of the object
tid	Not used.

Reimplemented from MooseObjectWarehouse< Constraint >.

Definition at line 24 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::addConstraint().

 {
   // Adds to the storage of _all_objects
   MooseObjectWarehouse<Constraint>::addObject(object);
 
   // Cast the the possible Contraint types
   std::shared_ptr<NodeFaceConstraint> nfc = std::dynamic_pointer_cast<NodeFaceConstraint>(object);
   std::shared_ptr<MortarConstraintBase> mc =
       std::dynamic_pointer_cast<MortarConstraintBase>(object);
   std::shared_ptr<NodalConstraint> nc = std::dynamic_pointer_cast<NodalConstraint>(object);
   std::shared_ptr<ElemElemConstraint> ec = std::dynamic_pointer_cast<ElemElemConstraint>(object);
   std::shared_ptr<NodeElemConstraintBase> nec =
       std::dynamic_pointer_cast<NodeElemConstraintBase>(object);
 
   // NodeFaceConstraint
   if (nfc)
   {
     MooseMesh & mesh = nfc->getParam<FEProblemBase *>("_fe_problem_base")->mesh();
     unsigned int secondary = mesh.getBoundaryID(nfc->getParam<BoundaryName>("secondary"));
     bool displaced = nfc->parameters().have_parameter<bool>("use_displaced_mesh") &&
                      nfc->getParam<bool>("use_displaced_mesh");
 
     if (displaced)
       _displaced_node_face_constraints[secondary].addObject(nfc);
     else
       _node_face_constraints[secondary].addObject(nfc);
   }
 
   // MortarConstraint
   else if (mc)
   {
     MooseMesh & mesh = mc->getParam<FEProblemBase *>("_fe_problem_base")->mesh();
     bool displaced = mc->getParam<bool>("use_displaced_mesh");
 
     auto secondary_boundary_id =
         mesh.getBoundaryID(mc->getParam<BoundaryName>("secondary_boundary"));
     auto primary_boundary_id = mesh.getBoundaryID(mc->getParam<BoundaryName>("primary_boundary"));
     auto key = std::make_pair(primary_boundary_id, secondary_boundary_id);
 
     if (displaced)
       _displaced_mortar_constraints[key].addObject(mc);
     else
       _mortar_constraints[key].addObject(mc);
   }
 
   // ElemElemConstraint
   else if (ec)
   {
     bool displaced = ec->parameters().have_parameter<bool>("use_displaced_mesh") &&
                      ec->getParam<bool>("use_displaced_mesh");
     const InterfaceID interface_id = ec->getInterfaceID();
 
     if (displaced)
       _displaced_element_constraints[interface_id].addObject(ec);
     else
       _element_constraints[interface_id].addObject(ec);
   }
 
   // NodeElemConstraintBase
   else if (nec)
   {
     MooseMesh & mesh = nec->getParam<FEProblemBase *>("_fe_problem_base")->mesh();
     SubdomainID secondary = mesh.getSubdomainID(nec->getParam<SubdomainName>("secondary"));
     SubdomainID primary = mesh.getSubdomainID(nec->getParam<SubdomainName>("primary"));
     bool displaced = nec->parameters().have_parameter<bool>("use_displaced_mesh") &&
                      nec->getParam<bool>("use_displaced_mesh");
 
     if (displaced)
       _displaced_node_elem_constraints[std::make_pair(secondary, primary)].addObject(nec);
     else
       _node_elem_constraints[std::make_pair(secondary, primary)].addObject(nec);
   }
 
   // NodalConstraint
   else if (nc)
     _nodal_constraints.addObject(nc);
 
   else
     mooseError("Unknown type of Constraint object");
 }

◆ checkThreadID()

void MooseObjectWarehouseBase< Constraint >::checkThreadID ( THREAD_ID tid ) const

inlineprotectedinherited

Calls assert on thread id.

Definition at line 905 of file MooseObjectWarehouseBase.h.

Referenced by residualEnd().

 {
   mooseAssert(tid < _num_threads,
               "Attempting to access a thread id ("
                   << tid << ") greater than the number allowed by the storage item ("
                   << _num_threads << ")");
 }

◆ customSetup()

void MooseObjectWarehouse< Constraint >::customSetup	(	const ExecFlagType &	exec_type,
		THREAD_ID	tid = `0`
	)		const

virtualinherited

Definition at line 176 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->customSetup(exec_type);
 }

◆ getActiveBlockObjects() [1/2]

const std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > & MooseObjectWarehouseBase< Constraint >::getActiveBlockObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 461 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _active_block_objects[tid];
 }

◆ getActiveBlockObjects() [2/2]

const std::vector< std::shared_ptr< Constraint > > & MooseObjectWarehouseBase< Constraint >::getActiveBlockObjects	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 469 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _active_block_objects[tid].find(id);
   mooseAssert(iter != _active_block_objects[tid].end(),
               "Unable to located active block objects for the given id: " << id << ".");
   return iter->second;
 }

◆ getActiveBlocks()

std::set< SubdomainID > MooseObjectWarehouseBase< Constraint >::getActiveBlocks ( THREAD_ID tid = 0 ) const

inherited

Return a set of active SubdomainsIDs.

Definition at line 625 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   std::set<SubdomainID> ids;
   for (const auto & object_pair : _active_block_objects[tid])
     ids.insert(object_pair.first);
   return ids;
 }

◆ getActiveBoundaryObjects() [1/2]

const std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > & MooseObjectWarehouseBase< Constraint >::getActiveBoundaryObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 442 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _active_boundary_objects[tid];
 }

◆ getActiveBoundaryObjects() [2/2]

const std::vector< std::shared_ptr< Constraint > > & MooseObjectWarehouseBase< Constraint >::getActiveBoundaryObjects	(	BoundaryID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 450 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _active_boundary_objects[tid].find(id);
   mooseAssert(iter != _active_boundary_objects[tid].end(),
               "Unable to located active boundary objects for the given id: " << id << ".");
   return iter->second;
 }

◆ getActiveElemElemConstraints()

const std::vector< std::shared_ptr< ElemElemConstraint > > & ConstraintWarehouse::getActiveElemElemConstraints	(	InterfaceID	interface_id,
		bool	displaced
	)		const

Definition at line 172 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::constraintJacobians(), and NonlinearSystemBase::constraintResiduals().

 {
   std::map<unsigned int, MooseObjectWarehouse<ElemElemConstraint>>::const_iterator it, end_it;
 
   if (displaced)
   {
     it = _displaced_element_constraints.find(interface_id);
     end_it = _displaced_element_constraints.end();
   }
 
   else
   {
     it = _element_constraints.find(interface_id);
     end_it = _element_constraints.end();
   }
 
   mooseAssert(it != end_it,
               "Unable to locate storage for ElemElemConstraint objects for the given interface id: "
                   << interface_id);
   return it->second.getActiveObjects();
 }

◆ getActiveMortarConstraints()

const std::vector< std::shared_ptr< MortarConstraintBase > > & ConstraintWarehouse::getActiveMortarConstraints	(	const std::pair< BoundaryID, BoundaryID > &	mortar_interface_key,
		bool	displaced
	)		const

Definition at line 145 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::initialSetup().

 {
   std::map<std::pair<BoundaryID, BoundaryID>,
            MooseObjectWarehouse<MortarConstraintBase>>::const_iterator it,
       end_it;
 
   if (displaced)
   {
     it = _displaced_mortar_constraints.find(mortar_interface_key);
     end_it = _displaced_mortar_constraints.end();
   }
   else
   {
     it = _mortar_constraints.find(mortar_interface_key);
     end_it = _mortar_constraints.end();
   }
 
   mooseAssert(
       it != end_it,
       "No MortarConstraints exist for the specified primary-secondary boundary pair, primary "
           << mortar_interface_key.first << " and secondary " << mortar_interface_key.second);
 
   return it->second.getActiveObjects();
 }

◆ getActiveNodalConstraints()

const std::vector< std::shared_ptr< NodalConstraint > > & ConstraintWarehouse::getActiveNodalConstraints ( ) const

Access methods for active objects.

Definition at line 108 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::enforceNodalConstraintsJacobian(), NonlinearSystemBase::enforceNodalConstraintsResidual(), and NonlinearSystemBase::findImplicitGeometricCouplingEntries().

 {
   return _nodal_constraints.getActiveObjects();
 }

◆ getActiveNodeElemConstraints()

const std::vector< std::shared_ptr< NodeElemConstraintBase > > & ConstraintWarehouse::getActiveNodeElemConstraints	(	SubdomainID	secondary_id,
		SubdomainID	primary_id,
		bool	displaced
	)		const

Definition at line 196 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), and NonlinearSystemBase::setConstraintSecondaryValues().

 {
   std::map<std::pair<SubdomainID, SubdomainID>,
            MooseObjectWarehouse<NodeElemConstraintBase>>::const_iterator it,
       end_it;
 
   if (displaced)
   {
     it = _displaced_node_elem_constraints.find(std::make_pair(secondary_id, primary_id));
     end_it = _displaced_node_elem_constraints.end();
   }
   else
   {
     it = _node_elem_constraints.find(std::make_pair(secondary_id, primary_id));
     end_it = _node_elem_constraints.end();
   }
 
   mooseAssert(
       it != end_it,
       "Unable to locate storage for NodeElemConstraintBase objects for the given secondary and "
       "primary id pair: ["
           << secondary_id << ", " << primary_id << "]");
   return it->second.getActiveObjects();
 }

◆ getActiveNodeFaceConstraints()

const std::vector< std::shared_ptr< NodeFaceConstraint > > & ConstraintWarehouse::getActiveNodeFaceConstraints	(	BoundaryID	boundary_id,
		bool	displaced
	)		const

Definition at line 114 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::overwriteNodeFace(), and NonlinearSystemBase::setConstraintSecondaryValues().

 {
   std::map<BoundaryID, MooseObjectWarehouse<NodeFaceConstraint>>::const_iterator it, end_it;
 
   if (displaced)
   {
     it = _displaced_node_face_constraints.find(boundary_id);
     end_it = _displaced_node_face_constraints.end();
   }
 
   else
   {
     it = _node_face_constraints.find(boundary_id);
     end_it = _node_face_constraints.end();
   }
 
   mooseAssert(it != end_it,
               "Unable to locate storage for NodeFaceConstraint objects for the given boundary id: "
                   << boundary_id);
   return it->second.getActiveObjects();
 }

◆ getActiveObject()

std::shared_ptr< Constraint > MooseObjectWarehouseBase< Constraint >::getActiveObject	(	const std::string &	name,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 606 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     if (object->name() == name)
       return object;
   mooseError("Unable to locate active object: ", name, ".");
 }

◆ getActiveObjects()

const std::vector< std::shared_ptr< Constraint > > & MooseObjectWarehouseBase< Constraint >::getActiveObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Retrieve complete vector to the active all/block/boundary restricted objects for a given thread.

Parameters

tid	The thread id to retrieve objects from

Definition at line 434 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _active_objects[tid];
 }

◆ getActiveVariableBlockObjects()

const std::vector< std::shared_ptr< Constraint > > & MooseObjectWarehouse< Constraint >::getActiveVariableBlockObjects	(	unsigned int	variable_id,
		SubdomainID	block_id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 143 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   const auto iter = _variable_objects.find(variable_id);
   mooseAssert(iter != _variable_objects.end(),
               "Unable to locate variable kernels for the given variable id: " << variable_id
                                                                               << ".");
   return iter->second.getActiveBlockObjects(block_id, tid);
 }

◆ getBlockObjects() [1/2]

const std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > & MooseObjectWarehouseBase< Constraint >::getBlockObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 415 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _all_block_objects[tid];
 }

◆ getBlockObjects() [2/2]

const std::vector< std::shared_ptr< Constraint > > & MooseObjectWarehouseBase< Constraint >::getBlockObjects	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 423 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _all_block_objects[tid].find(id);
   mooseAssert(iter != _all_block_objects[tid].end(),
               "Unable to located active block objects for the given id: " << id << ".");
   return iter->second;
 }

◆ getBoundaryObjects() [1/2]

const std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > & MooseObjectWarehouseBase< Constraint >::getBoundaryObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 388 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _all_boundary_objects[tid];
 }

◆ getBoundaryObjects() [2/2]

const std::vector< std::shared_ptr< Constraint > > & MooseObjectWarehouseBase< Constraint >::getBoundaryObjects	(	BoundaryID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 404 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _all_boundary_objects[tid].find(id);
   mooseAssert(iter != _all_boundary_objects[tid].end(),
               "Unable to located active boundary objects for the given id: " << id << ".");
   return iter->second;
 }

◆ getObject()

std::shared_ptr< Constraint > MooseObjectWarehouseBase< Constraint >::getObject	(	const std::string &	name,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 595 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   for (const auto & object : _all_objects[tid])
     if (object->name() == name)
       return object;
   mooseError("Unable to locate object: ", name, ".");
 }

◆ getObjects()

const std::vector< std::shared_ptr< Constraint > > & MooseObjectWarehouseBase< Constraint >::getObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Retrieve complete vector to the all/block/boundary restricted objects for a given thread.

Parameters

tid	The thread id to retrieve objects from

Definition at line 380 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _all_objects[tid];
 }

◆ getObjectsForVariable()

const std::vector< std::shared_ptr< Constraint > > & MooseObjectWarehouseBase< Constraint >::getObjectsForVariable	(	const VariableName &	var_name,
		THREAD_ID	tid
	)		const

inherited

Getter for objects that have the 'variable' set to a particular variable Note that users should check whether there are objects using 'hasObjectsForVariable' before calling this routine, because it will throw if there are no objects for this variable.

Definition at line 617 of file MooseObjectWarehouseBase.h.

 {
   return libmesh_map_find(_all_variable_objects[tid], var_name);
 }

◆ hasActiveBlockObjects() [1/2]

bool MooseObjectWarehouseBase< Constraint >::hasActiveBlockObjects ( THREAD_ID tid = 0 ) const

inherited

Definition at line 544 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   bool has_active_block_objects = false;
   for (const auto & object_pair : _active_block_objects[tid])
     has_active_block_objects |= !(object_pair.second.empty());
   return has_active_block_objects;
 }

◆ hasActiveBlockObjects() [2/2]

bool MooseObjectWarehouseBase< Constraint >::hasActiveBlockObjects	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 555 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _active_block_objects[tid].find(id);
   return iter != _active_block_objects[tid].end();
 }

◆ hasActiveBoundaryObjects() [1/2]

bool MooseObjectWarehouseBase< Constraint >::hasActiveBoundaryObjects ( THREAD_ID tid = 0 ) const

inherited

Definition at line 564 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   bool has_active_boundary_objects = false;
   for (const auto & object_pair : _active_boundary_objects[tid])
     has_active_boundary_objects |= !(object_pair.second.empty());
   return has_active_boundary_objects;
 }

◆ hasActiveBoundaryObjects() [2/2]

bool MooseObjectWarehouseBase< Constraint >::hasActiveBoundaryObjects	(	BoundaryID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 575 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _active_boundary_objects[tid].find(id);
   return iter != _active_boundary_objects[tid].end();
 }

◆ hasActiveElemElemConstraints()

bool ConstraintWarehouse::hasActiveElemElemConstraints	(	const InterfaceID	interface_id,
		bool	displaced
	)		const

Definition at line 230 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::constraintJacobians(), and NonlinearSystemBase::constraintResiduals().

 {
   std::map<unsigned int, MooseObjectWarehouse<ElemElemConstraint>>::const_iterator it, end_it;
 
   if (displaced)
   {
     it = _displaced_element_constraints.find(interface_id);
     end_it = _displaced_element_constraints.end();
   }
 
   else
   {
     it = _element_constraints.find(interface_id);
     end_it = _element_constraints.end();
   }
 
   return (it != end_it && it->second.hasActiveObjects());
 }

◆ hasActiveMortarConstraints()

bool ConstraintWarehouse::hasActiveMortarConstraints	(	const std::pair< BoundaryID, BoundaryID > &	mortar_interface_key,
		bool	displaced
	)		const

Definition at line 137 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::initialSetup().

 {
   const auto & constraints = displaced ? _displaced_mortar_constraints : _mortar_constraints;
   return constraints.find(mortar_interface_key) != constraints.end();
 }

◆ hasActiveNodalConstraints()

bool ConstraintWarehouse::hasActiveNodalConstraints ( ) const

Deterimine if active objects exist.

Definition at line 224 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::enforceNodalConstraintsJacobian(), and NonlinearSystemBase::enforceNodalConstraintsResidual().

 {
   return _nodal_constraints.hasActiveObjects();
 }

◆ hasActiveNodeElemConstraints()

bool ConstraintWarehouse::hasActiveNodeElemConstraints	(	SubdomainID	secondary_id,
		SubdomainID	primary_id,
		bool	displaced
	)		const

Definition at line 271 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), and NonlinearSystemBase::setConstraintSecondaryValues().

 {
   std::map<std::pair<SubdomainID, SubdomainID>,
            MooseObjectWarehouse<NodeElemConstraintBase>>::const_iterator it,
       end_it;
 
   if (displaced)
   {
     it = _displaced_node_elem_constraints.find(std::make_pair(secondary_id, primary_id));
     end_it = _displaced_node_elem_constraints.end();
   }
 
   else
   {
     it = _node_elem_constraints.find(std::make_pair(secondary_id, primary_id));
     end_it = _node_elem_constraints.end();
   }
 
   return (it != end_it && it->second.hasActiveObjects());
 }

◆ hasActiveNodeFaceConstraints()

bool ConstraintWarehouse::hasActiveNodeFaceConstraints	(	BoundaryID	boundary_id,
		bool	displaced
	)		const

Definition at line 251 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::overwriteNodeFace(), and NonlinearSystemBase::setConstraintSecondaryValues().

 {
   std::map<BoundaryID, MooseObjectWarehouse<NodeFaceConstraint>>::const_iterator it, end_it;
 
   if (displaced)
   {
     it = _displaced_node_face_constraints.find(boundary_id);
     end_it = _displaced_node_face_constraints.end();
   }
 
   else
   {
     it = _node_face_constraints.find(boundary_id);
     end_it = _node_face_constraints.end();
   }
 
   return (it != end_it && it->second.hasActiveObjects());
 }

◆ hasActiveObject()

bool MooseObjectWarehouseBase< Constraint >::hasActiveObject	(	const std::string &	name,
		THREAD_ID	tid = `0`
	)		const

inherited

Convenience functions for checking/getting specific objects.

Definition at line 584 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     if (object->name() == name)
       return true;
   return false;
 }

◆ hasActiveObjects()

bool MooseObjectWarehouseBase< Constraint >::hasActiveObjects ( THREAD_ID tid = 0 ) const

inherited

Definition at line 488 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return !_active_objects[tid].empty();
 }

◆ hasActiveVariableBlockObjects()

bool MooseObjectWarehouse< Constraint >::hasActiveVariableBlockObjects	(	unsigned int	variable_id,
		SubdomainID	block_id,
		THREAD_ID	tid = `0`
	)		const

inherited

Methods for checking/getting variable kernels for a variable and SubdomainID.

Definition at line 133 of file MooseObjectWarehouse.h.

 {
   auto iter = _variable_objects.find(variable_id);
   return (iter != _variable_objects.end() && iter->second.hasActiveBlockObjects(block_id, tid));
 }

◆ hasBoundaryObjects()

bool MooseObjectWarehouseBase< Constraint >::hasBoundaryObjects	(	BoundaryID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 396 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _all_boundary_objects[tid].find(id) != _all_boundary_objects[tid].end();
 }

◆ hasObjects()

bool MooseObjectWarehouseBase< Constraint >::hasObjects ( THREAD_ID tid = 0 ) const

inherited

Convenience functions for determining if objects exist.

Definition at line 480 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return !_all_objects[tid].empty();
 }

◆ hasObjectsForVariable()

bool MooseObjectWarehouseBase< Constraint >::hasObjectsForVariable	(	const VariableName &	var_name,
		THREAD_ID	tid
	)		const

inherited

Definition at line 496 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _all_variable_objects[tid].count(var_name);
 }

◆ hasObjectsForVariableAndBlocks()

bool MooseObjectWarehouseBase< Constraint >::hasObjectsForVariableAndBlocks	(	const VariableName &	var_name,
		const std::set< SubdomainID > &	blocks,
		std::set< SubdomainID > &	blocks_covered,
		THREAD_ID	tid
	)		const

inherited

Whether there are objects for this variable and the set of blocks passed.

Parameters

var_name	name of the variable
blocks	blocks to consider
blocks_covered	subset of blocks for which there is an object

Definition at line 505 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   blocks_covered.clear();
   if (!hasObjectsForVariable(var_name, tid))
     return false;
 
   // Check block restriction as a whole
   for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
   {
     std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
     if (blk && blk->hasBlocks(blocks))
     {
       blocks_covered = blocks;
       return true;
     }
   }
   // No object has all the blocks, but one might overlap, which could be troublesome.
   // We'll keep track of which blocks are covered in case several overlap
   for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
   {
     std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
     if (blk)
       for (const auto & block : blocks)
         if (blk->hasBlocks(block))
           blocks_covered.insert(block);
   }
   // No overlap at all
   if (blocks_covered.empty())
     return false;
 
   return (blocks == blocks_covered);
 }

◆ hasVariableObjects()

bool MooseObjectWarehouse< Constraint >::hasVariableObjects	(	unsigned int	variable_id,
		THREAD_ID	tid = `0`
	)		const

inherited

Checks for whether this warehouse has objects for a given variable.

Definition at line 125 of file MooseObjectWarehouse.h.

 {
   auto iter = _variable_objects.find(variable_id);
   return (iter != _variable_objects.end() && iter->second.hasObjects(tid));
 }

◆ initialSetup()

void MooseObjectWarehouse< Constraint >::initialSetup ( THREAD_ID tid = 0 ) const

virtualinherited

Convenience methods for calling object setup methods.

Definition at line 157 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   // Initial Setup should be called on all objects because they may become active later
   for (const auto & object : _all_objects[tid])
     object->initialSetup();
 }

◆ jacobianSetup()

void MooseObjectWarehouse< Constraint >::jacobianSetup ( THREAD_ID tid = 0 ) const

virtualinherited

Definition at line 207 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->jacobianSetup();
 }

◆ numThreads()

THREAD_ID MooseObjectWarehouseBase< Constraint >::numThreads ( ) const

inlineinherited

Return the number of threads.

Definition at line 204 of file MooseObjectWarehouseBase.h.

204 { return _num_threads; }

MooseObjectWarehouseBase< Constraint >::_num_threads

const THREAD_ID _num_threads

Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) ...

Definition: MooseObjectWarehouseBase.h:216

◆ residualEnd()

void ConstraintWarehouse::residualEnd ( THREAD_ID tid = 0 ) const

virtual

Definition at line 358 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::computeResidualInternal().

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->residualEnd();
 }

◆ residualSetup()

void MooseObjectWarehouse< Constraint >::residualSetup ( THREAD_ID tid = 0 ) const

virtualinherited

Definition at line 216 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->residualSetup();
 }

◆ size()

unsigned int MooseObjectWarehouseBase< Constraint >::size ( THREAD_ID tid = 0 ) const

inherited

Return how many kernels we store in the current warehouse.

Definition at line 298 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _all_objects[tid].size();
 }

◆ sort()

void MooseObjectWarehouseBase< Constraint >::sort ( THREAD_ID tid = 0 )

inherited

Sort the objects using the DependencyResolver.

Definition at line 665 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
 
   for (auto & object_pair : _all_block_objects[tid])
     sortHelper(object_pair.second);
 
   for (auto & object_pair : _all_boundary_objects[tid])
     sortHelper(object_pair.second);
 
   sortHelper(_all_objects[tid]);
 
   // The active lists now must be update to reflect the order changes
   updateActive(tid);
 }

◆ sortHelper()

void MooseObjectWarehouseBase< Constraint >::sortHelper ( std::vector< std::shared_ptr< Constraint >> & objects )

staticprotectedinherited

Helper method for sorting vectors of objects.

Definition at line 885 of file MooseObjectWarehouseBase.h.

 {
   // Do nothing if the vector is empty
   if (objects.empty())
     return;
 
   try
   {
     // Sort based on dependencies
     DependencyResolverInterface::sort<std::shared_ptr<T>>(objects);
   }
   catch (CyclicDependencyException<std::shared_ptr<T>> & e)
   {
     DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<T>>(
         e, "Cyclic dependency detected in object ordering");
   }
 }

◆ subdomainsCovered()

void ConstraintWarehouse::subdomainsCovered	(	std::set< SubdomainID > &	subdomains_covered,
		std::set< std::string > &	unique_variables,
		THREAD_ID	tid = `0`
	)		const

Update supplied subdomain and variable coverate containters.

Definition at line 318 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::checkKernelCoverage().

 {
   // Loop over undisplaced
   for (const auto & pr : _mortar_constraints)
   {
     const auto & objects = pr.second.getActiveObjects();
     for (const auto & mc : objects)
     {
       const MooseVariableFEBase * lm_var = mc->variablePtr();
       if (lm_var)
         unique_variables.insert(lm_var->name());
 
       // Mortar constraints will cover primary and secondary subdomains regardless of whether we
       // have a Lagrange multiplier associated.
       subdomains_covered.insert(mc->primarySubdomain());
       subdomains_covered.insert(mc->secondarySubdomain());
     }
   }
 
   // Loop over displaced
   for (const auto & pr : _displaced_mortar_constraints)
   {
     const auto & objects = pr.second.getActiveObjects();
     for (const auto & mc : objects)
     {
       const MooseVariableFEBase * lm_var = mc->variablePtr();
       if (lm_var)
         unique_variables.insert(lm_var->name());
 
       // Mortar constraints will cover primary and secondary subdomains regardless of whether we
       // have a Lagrange multiplier associated.
       subdomains_covered.insert(mc->primarySubdomain());
       subdomains_covered.insert(mc->secondarySubdomain());
     }
   }
 }

◆ subdomainSetup() [1/2]

void MooseObjectWarehouse< Constraint >::subdomainSetup ( THREAD_ID tid = 0 ) const

virtualinherited

Definition at line 198 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->subdomainSetup();
 }

◆ subdomainSetup() [2/2]

void MooseObjectWarehouse< Constraint >::subdomainSetup	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

virtualinherited

Definition at line 185 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   if (hasActiveBlockObjects(id, tid))
   {
     const auto & objects = getActiveBlockObjects(id, tid);
     for (const auto & object : objects)
       object->subdomainSetup();
   }
 }

◆ timestepSetup()

void MooseObjectWarehouse< Constraint >::timestepSetup ( THREAD_ID tid = 0 ) const

virtualinherited

Definition at line 167 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->timestepSetup();
 }

◆ updateActive()

void ConstraintWarehouse::updateActive ( THREAD_ID tid = 0 )

overridevirtual

Update the various active lists.

Reimplemented from MooseObjectWarehouse< Constraint >.

Definition at line 295 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::updateActive().

 {
   MooseObjectWarehouse<Constraint>::updateActive();
   _nodal_constraints.updateActive();
 
   for (auto & it : _node_face_constraints)
     it.second.updateActive();
 
   for (auto & it : _displaced_node_face_constraints)
     it.second.updateActive();
 
   // FIXME: We call updateActive() on the NodeFaceConstraints again?
   for (auto & it : _node_face_constraints)
     it.second.updateActive();
 
   for (auto & it : _element_constraints)
     it.second.updateActive();
 
   for (auto & it : _node_elem_constraints)
     it.second.updateActive();
 }

◆ updateActiveHelper()

void MooseObjectWarehouseBase< Constraint >::updateActiveHelper	(	std::vector< std::shared_ptr< Constraint >> &	active,
		const std::vector< std::shared_ptr< Constraint >> &	all
	)

staticprotectedinherited

Helper method for updating active vectors.

Definition at line 651 of file MooseObjectWarehouseBase.h.

 {
   // Clear the active list
   active.clear();
 
   std::copy_if(all.begin(),
                all.end(),
                std::back_inserter(active),
                [](const std::shared_ptr<T> & object) { return object->enabled(); });
 }

◆ updateBlockFEVariableCoupledVectorTagDependency()

void MooseObjectWarehouseBase< Constraint >::updateBlockFEVariableCoupledVectorTagDependency	(	SubdomainID	id,
		std::set< TagID > &	needed_fe_var_vector_tags,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 754 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBlockObjects(id, tid))
     updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                      getActiveBlockObjects(id, tid));
 }

◆ updateBlockMatPropDependency()

void MooseObjectWarehouseBase< Constraint >::updateBlockMatPropDependency	(	SubdomainID	id,
		std::unordered_set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`,
		const bool	producer_only = `false`
	)		const

inherited

Definition at line 801 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBlockObjects(id, tid))
     updateMatPropDependencyHelper(needed_mat_props, getActiveBlockObjects(id, tid), producer_only);
 }

◆ updateBlockVariableDependency()

void MooseObjectWarehouseBase< Constraint >::updateBlockVariableDependency	(	SubdomainID	id,
		std::set< MooseVariableFieldBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 692 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBlockObjects(id, tid))
     updateVariableDependencyHelper(needed_moose_vars, getActiveBlockObjects(id, tid));
 }

◆ updateBoundaryFEVariableCoupledVectorTagDependency()

void MooseObjectWarehouseBase< Constraint >::updateBoundaryFEVariableCoupledVectorTagDependency	(	BoundaryID	id,
		std::set< TagID > &	needed_fe_var_vector_tags,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 764 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBoundaryObjects(id, tid))
     updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                      getActiveBoundaryObjects(id, tid));
 }

◆ updateBoundaryMatPropDependency() [1/2]

void MooseObjectWarehouseBase< Constraint >::updateBoundaryMatPropDependency	(	std::unordered_set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`,
		const bool	producer_only = `false`
	)		const

inherited

Definition at line 813 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBoundaryObjects(tid))
     for (auto & active_bnd_object : _active_boundary_objects[tid])
       updateMatPropDependencyHelper(needed_mat_props, active_bnd_object.second, producer_only);
 }

◆ updateBoundaryMatPropDependency() [2/2]

void MooseObjectWarehouseBase< Constraint >::updateBoundaryMatPropDependency	(	BoundaryID	id,
		std::unordered_set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`,
		const bool	producer_only = `false`
	)		const

inherited

Definition at line 825 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBoundaryObjects(id, tid))
     updateMatPropDependencyHelper(
         needed_mat_props, getActiveBoundaryObjects(id, tid), producer_only);
 }

◆ updateBoundaryVariableDependency() [1/2]

void MooseObjectWarehouseBase< Constraint >::updateBoundaryVariableDependency	(	std::set< MooseVariableFieldBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 703 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBoundaryObjects(tid))
   {
     typename std::map<BoundaryID, std::vector<std::shared_ptr<T>>>::const_iterator it;
     for (const auto & object_pair : _active_boundary_objects[tid])
       updateVariableDependencyHelper(needed_moose_vars, object_pair.second);
   }
 }

◆ updateBoundaryVariableDependency() [2/2]

void MooseObjectWarehouseBase< Constraint >::updateBoundaryVariableDependency	(	BoundaryID	id,
		std::set< MooseVariableFieldBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 716 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBoundaryObjects(id, tid))
     updateVariableDependencyHelper(needed_moose_vars, getActiveBoundaryObjects(id, tid));
 }

◆ updateFEVariableCoupledVectorTagDependency()

void MooseObjectWarehouseBase< Constraint >::updateFEVariableCoupledVectorTagDependency	(	std::set< TagID > &	needed_fe_var_vector_tags,
		THREAD_ID	tid = `0`
	)		const

inherited

Update FE variable coupleable vector tag vector for all objects, block-restricted objects, and boundary-restricted objects.

Definition at line 744 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveObjects(tid))
     updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                      _active_objects[tid]);
 }

◆ updateFEVariableCoupledVectorTagDependencyHelper()

void MooseObjectWarehouseBase< Constraint >::updateFEVariableCoupledVectorTagDependencyHelper	(	std::set< TagID > &	needed_fe_var_vector_tags,
		const std::vector< std::shared_ptr< Constraint >> &	objects
	)

staticprotectedinherited

Helper method for updating FE variable coupleable vector tag vector.

Definition at line 774 of file MooseObjectWarehouseBase.h.

 {
   for (const auto & object : objects)
   {
     auto c = dynamic_cast<const Coupleable *>(object.get());
     if (c)
     {
       const auto & tag_deps = c->getFEVariableCoupleableVectorTags();
       needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
     }
   }
 }

◆ updateMatPropDependency()

void MooseObjectWarehouseBase< Constraint >::updateMatPropDependency	(	std::unordered_set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`,
		const bool	producer_only = `false`
	)		const

inherited

Update material property dependency vector.

Parameters

producer_only Only append dependencies of materials producing the needed_mat_props

Definition at line 790 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveObjects(tid))
     updateMatPropDependencyHelper(needed_mat_props, _active_objects[tid], producer_only);
 }

◆ updateMatPropDependencyHelper()

void MooseObjectWarehouseBase< Constraint >::updateMatPropDependencyHelper	(	std::unordered_set< unsigned int > &	needed_mat_props,
		const std::vector< std::shared_ptr< Constraint >> &	objects,
		const bool	producer_only
	)		const

protectedvirtualinherited

Helper method for updating material property dependency vector.

Definition at line 838 of file MooseObjectWarehouseBase.h.

 {
   for (auto & object : objects)
   {
     auto c = dynamic_cast<const MaterialPropertyInterface *>(object.get());
     if (c)
     {
       auto & mp_deps = c->getMatPropDependencies();
       needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
     }
   }
 }

◆ updateVariableDependency()

void MooseObjectWarehouseBase< Constraint >::updateVariableDependency	(	std::set< MooseVariableFieldBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Update variable dependency vector.

Definition at line 683 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveObjects(tid))
     updateVariableDependencyHelper(needed_moose_vars, _active_objects[tid]);
 }

◆ updateVariableDependencyHelper()

void MooseObjectWarehouseBase< Constraint >::updateVariableDependencyHelper	(	std::set< MooseVariableFieldBase *> &	needed_moose_vars,
		const std::vector< std::shared_ptr< Constraint >> &	objects
	)

staticprotectedinherited

Helper method for updating variable dependency vector.

Definition at line 727 of file MooseObjectWarehouseBase.h.

 {
   for (const auto & object : objects)
   {
     auto c = dynamic_cast<const MooseVariableDependencyInterface *>(object.get());
     if (c)
     {
       const auto & mv_deps = c->getMooseVariableDependencies();
       needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
     }
   }
 }

Member Data Documentation

◆ _active_block_objects

std::vector<std::map<SubdomainID, std::vector<std::shared_ptr<Constraint > > > > MooseObjectWarehouseBase< Constraint >::_active_block_objects

protectedinherited

Active block restricted objects (THREAD_ID on outer vector)

Definition at line 228 of file MooseObjectWarehouseBase.h.

◆ _active_boundary_objects

std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<Constraint > > > > MooseObjectWarehouseBase< Constraint >::_active_boundary_objects

protectedinherited

Active boundary restricted objects (THREAD_ID on outer vector)

Definition at line 234 of file MooseObjectWarehouseBase.h.

◆ _active_objects

std::vector<std::vector<std::shared_ptr<Constraint > > > MooseObjectWarehouseBase< Constraint >::_active_objects

protectedinherited

All active objects (THREAD_ID on outer vector)

Definition at line 222 of file MooseObjectWarehouseBase.h.

Referenced by residualEnd().

◆ _all_block_objects

std::vector<std::map<SubdomainID, std::vector<std::shared_ptr<Constraint > > > > MooseObjectWarehouseBase< Constraint >::_all_block_objects

protectedinherited

Definition at line 225 of file MooseObjectWarehouseBase.h.

◆ _all_boundary_objects

std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<Constraint > > > > MooseObjectWarehouseBase< Constraint >::_all_boundary_objects

protectedinherited

Definition at line 231 of file MooseObjectWarehouseBase.h.

◆ _all_objects

std::vector<std::vector<std::shared_ptr<Constraint > > > MooseObjectWarehouseBase< Constraint >::_all_objects

protectedinherited

Storage container for the ALL pointers (THREAD_ID on outer vector)

Definition at line 219 of file MooseObjectWarehouseBase.h.

◆ _all_variable_objects

std::vector<std::map<VariableName, std::vector<std::shared_ptr<Constraint > > > > MooseObjectWarehouseBase< Constraint >::_all_variable_objects

protectedinherited

All objects with a certain variable selected, as the 'variable' parameter.

Definition at line 237 of file MooseObjectWarehouseBase.h.

◆ _displaced_element_constraints

std::map<unsigned int, MooseObjectWarehouse<ElemElemConstraint> > ConstraintWarehouse::_displaced_element_constraints

protected

ElemElemConstraints (displaced)

Definition at line 105 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveElemElemConstraints(), and hasActiveElemElemConstraints().

◆ _displaced_mortar_constraints

std::map<std::pair<BoundaryID, BoundaryID>, MooseObjectWarehouse<MortarConstraintBase> > ConstraintWarehouse::_displaced_mortar_constraints

protected

Displaced MortarConstraints.

Definition at line 99 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveMortarConstraints(), hasActiveMortarConstraints(), and subdomainsCovered().

◆ _displaced_node_elem_constraints

std::map<std::pair<SubdomainID, SubdomainID>, MooseObjectWarehouse<NodeElemConstraintBase> > ConstraintWarehouse::_displaced_node_elem_constraints

protected

NodeElemConstraint objects.

Definition at line 113 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveNodeElemConstraints(), and hasActiveNodeElemConstraints().

◆ _displaced_node_face_constraints

std::map<BoundaryID, MooseObjectWarehouse<NodeFaceConstraint> > ConstraintWarehouse::_displaced_node_face_constraints

protected

NodeFaceConstraint objects (displaced)

Definition at line 91 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveNodeFaceConstraints(), hasActiveNodeFaceConstraints(), and updateActive().

◆ _element_constraints

std::map<unsigned int, MooseObjectWarehouse<ElemElemConstraint> > ConstraintWarehouse::_element_constraints

protected

ElemElemConstraints (non-displaced)

Definition at line 102 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveElemElemConstraints(), hasActiveElemElemConstraints(), and updateActive().

◆ _mortar_constraints

std::map<std::pair<BoundaryID, BoundaryID>, MooseObjectWarehouse<MortarConstraintBase> > ConstraintWarehouse::_mortar_constraints

protected

Undisplaced MortarConstraints.

Definition at line 95 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveMortarConstraints(), hasActiveMortarConstraints(), and subdomainsCovered().

◆ _nodal_constraints

MooseObjectWarehouse<NodalConstraint> ConstraintWarehouse::_nodal_constraints

protected

NodalConstraint objects.

Definition at line 85 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveNodalConstraints(), hasActiveNodalConstraints(), and updateActive().

◆ _node_elem_constraints

std::map<std::pair<SubdomainID, SubdomainID>, MooseObjectWarehouse<NodeElemConstraintBase> > ConstraintWarehouse::_node_elem_constraints

protected

NodeElemConstraint objects.

Definition at line 109 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveNodeElemConstraints(), hasActiveNodeElemConstraints(), and updateActive().

◆ _node_face_constraints

std::map<BoundaryID, MooseObjectWarehouse<NodeFaceConstraint> > ConstraintWarehouse::_node_face_constraints

protected

NodeFaceConstraint objects (non-displaced)

Definition at line 88 of file ConstraintWarehouse.h.

Referenced by addObject(), getActiveNodeFaceConstraints(), hasActiveNodeFaceConstraints(), and updateActive().

◆ _num_threads

const THREAD_ID MooseObjectWarehouseBase< Constraint >::_num_threads

protectedinherited

Convenience member storing the number of threads used for storage (1 or libMesh::n_threads)

Definition at line 216 of file MooseObjectWarehouseBase.h.

◆ _variable_objects

std::map<unsigned int, MooseObjectWarehouse<Constraint > > MooseObjectWarehouse< Constraint >::_variable_objects

protectedinherited

Variable based storage.

Definition at line 88 of file MooseObjectWarehouse.h.

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

include/constraints/ConstraintWarehouse.h
src/constraints/ConstraintWarehouse.C

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ConstraintWarehouse()

Member Function Documentation

◆ activeObjectsToFormattedString()

◆ addObject()

◆ checkThreadID()

◆ customSetup()

◆ getActiveBlockObjects() [1/2]

◆ getActiveBlockObjects() [2/2]

◆ getActiveBlocks()

◆ getActiveBoundaryObjects() [1/2]

◆ getActiveBoundaryObjects() [2/2]

◆ getActiveElemElemConstraints()

◆ getActiveMortarConstraints()

◆ getActiveNodalConstraints()

◆ getActiveNodeElemConstraints()

◆ getActiveNodeFaceConstraints()

◆ getActiveObject()

◆ getActiveObjects()

◆ getActiveVariableBlockObjects()

◆ getBlockObjects() [1/2]

◆ getBlockObjects() [2/2]

◆ getBoundaryObjects() [1/2]

◆ getBoundaryObjects() [2/2]

◆ getObject()

◆ getObjects()

◆ getObjectsForVariable()

◆ hasActiveBlockObjects() [1/2]

◆ hasActiveBlockObjects() [2/2]

◆ hasActiveBoundaryObjects() [1/2]

◆ hasActiveBoundaryObjects() [2/2]

◆ hasActiveElemElemConstraints()

◆ hasActiveMortarConstraints()

◆ hasActiveNodalConstraints()

◆ hasActiveNodeElemConstraints()

◆ hasActiveNodeFaceConstraints()

◆ hasActiveObject()

◆ hasActiveObjects()

◆ hasActiveVariableBlockObjects()

◆ hasBoundaryObjects()

◆ hasObjects()

◆ hasObjectsForVariable()

◆ hasObjectsForVariableAndBlocks()

◆ hasVariableObjects()

◆ initialSetup()

◆ jacobianSetup()

◆ numThreads()

◆ residualEnd()

◆ residualSetup()

◆ size()

◆ sort()

◆ sortHelper()

◆ subdomainsCovered()

◆ subdomainSetup() [1/2]

◆ subdomainSetup() [2/2]

◆ timestepSetup()

◆ updateActive()

◆ updateActiveHelper()

◆ updateBlockFEVariableCoupledVectorTagDependency()

◆ updateBlockMatPropDependency()

◆ updateBlockVariableDependency()

◆ updateBoundaryFEVariableCoupledVectorTagDependency()

◆ updateBoundaryMatPropDependency() [1/2]

◆ updateBoundaryMatPropDependency() [2/2]

◆ updateBoundaryVariableDependency() [1/2]

◆ updateBoundaryVariableDependency() [2/2]

◆ updateFEVariableCoupledVectorTagDependency()

◆ updateFEVariableCoupledVectorTagDependencyHelper()

◆ updateMatPropDependency()

◆ updateMatPropDependencyHelper()

◆ updateVariableDependency()

◆ updateVariableDependencyHelper()

Member Data Documentation

◆ _active_block_objects

◆ _active_boundary_objects