https://mooseframework.inl.gov
Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
ConstraintWarehouse Class Reference

Warehouse for storing constraints. More...

#include <ConstraintWarehouse.h>

Inheritance diagram for ConstraintWarehouse:
[legend]

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 updateBlockFEVariableCoupledVectorTagDependency (SubdomainID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
 Update FE variable coupleable vector tag vector. More...
 
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
 Update material property dependency vector. More...
 
void updateBlockMatPropDependency (SubdomainID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
 
void updateBoundaryMatPropDependency (std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
 
void updateBoundaryMatPropDependency (BoundaryID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
 

Protected Member Functions

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...
 
static void updateMatPropDependencyHelper (std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< Constraint >> &objects)
 Helper method for updating material property dependency 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) {}

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
tidthe thread id
prefixa string to prepend to the string

Definition at line 847 of file MooseObjectWarehouseBase.h.

849 {
850  std::vector<std::string> output;
851  for (const auto & object : _active_objects[tid])
852  output.push_back(object->name());
853  return ConsoleUtils::formatString(MooseUtils::join(output, " "), prefix);
854 }
MooseUtils::join
std::string join(Iterator begin, Iterator end, const std::string &delimiter)
Python-like join function for strings over an iterator range.
Definition: MooseUtils.h:142
ConsoleUtils::formatString
std::string formatString(std::string message, const std::string &prefix)
Add new lines and prefixes to a string for pretty display in output NOTE: This makes a copy of the st...
Definition: ConsoleUtils.C:581
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ addObject()

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

Add Constraint object to the warehouse.

Parameters
objectA std::shared_ptr of the object
tidNot used.

Reimplemented from MooseObjectWarehouse< Constraint >.

Definition at line 24 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::addConstraint().

27 {
28  // Adds to the storage of _all_objects
29  MooseObjectWarehouse<Constraint>::addObject(object);
30 
31  // Cast the the possible Contraint types
32  std::shared_ptr<NodeFaceConstraint> nfc = std::dynamic_pointer_cast<NodeFaceConstraint>(object);
33  std::shared_ptr<MortarConstraintBase> mc =
34  std::dynamic_pointer_cast<MortarConstraintBase>(object);
35  std::shared_ptr<NodalConstraint> nc = std::dynamic_pointer_cast<NodalConstraint>(object);
36  std::shared_ptr<ElemElemConstraint> ec = std::dynamic_pointer_cast<ElemElemConstraint>(object);
37  std::shared_ptr<NodeElemConstraintBase> nec =
38  std::dynamic_pointer_cast<NodeElemConstraintBase>(object);
39 
40  // NodeFaceConstraint
41  if (nfc)
42  {
43  MooseMesh & mesh = nfc->getParam<FEProblemBase *>("_fe_problem_base")->mesh();
44  unsigned int secondary = mesh.getBoundaryID(nfc->getParam<BoundaryName>("secondary"));
45  bool displaced = nfc->parameters().have_parameter<bool>("use_displaced_mesh") &&
46  nfc->getParam<bool>("use_displaced_mesh");
47 
48  if (displaced)
49  _displaced_node_face_constraints[secondary].addObject(nfc);
50  else
51  _node_face_constraints[secondary].addObject(nfc);
52  }
53 
54  // MortarConstraint
55  else if (mc)
56  {
57  MooseMesh & mesh = mc->getParam<FEProblemBase *>("_fe_problem_base")->mesh();
58  bool displaced = mc->getParam<bool>("use_displaced_mesh");
59 
60  auto secondary_boundary_id =
61  mesh.getBoundaryID(mc->getParam<BoundaryName>("secondary_boundary"));
62  auto primary_boundary_id = mesh.getBoundaryID(mc->getParam<BoundaryName>("primary_boundary"));
63  auto key = std::make_pair(primary_boundary_id, secondary_boundary_id);
64 
65  if (displaced)
66  _displaced_mortar_constraints[key].addObject(mc);
67  else
68  _mortar_constraints[key].addObject(mc);
69  }
70 
71  // ElemElemConstraint
72  else if (ec)
73  {
74  bool displaced = ec->parameters().have_parameter<bool>("use_displaced_mesh") &&
75  ec->getParam<bool>("use_displaced_mesh");
76  const InterfaceID interface_id = ec->getInterfaceID();
77 
78  if (displaced)
79  _displaced_element_constraints[interface_id].addObject(ec);
80  else
81  _element_constraints[interface_id].addObject(ec);
82  }
83 
84  // NodeElemConstraintBase
85  else if (nec)
86  {
87  MooseMesh & mesh = nec->getParam<FEProblemBase *>("_fe_problem_base")->mesh();
88  SubdomainID secondary = mesh.getSubdomainID(nec->getParam<SubdomainName>("secondary"));
89  SubdomainID primary = mesh.getSubdomainID(nec->getParam<SubdomainName>("primary"));
90  bool displaced = nec->parameters().have_parameter<bool>("use_displaced_mesh") &&
91  nec->getParam<bool>("use_displaced_mesh");
92 
93  if (displaced)
94  _displaced_node_elem_constraints[std::make_pair(secondary, primary)].addObject(nec);
95  else
96  _node_elem_constraints[std::make_pair(secondary, primary)].addObject(nec);
97  }
98 
99  // NodalConstraint
100  else if (nc)
101  _nodal_constraints.addObject(nc);
102 
103  else
104  mooseError("Unknown type of Constraint object");
105 }
ConstraintWarehouse::_displaced_mortar_constraints
std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > > _displaced_mortar_constraints
Displaced MortarConstraints.
Definition: ConstraintWarehouse.h:99
MortarConstraintBase
User for mortar methods.
Definition: MortarConstraintBase.h:42
ConstraintWarehouse::_nodal_constraints
MooseObjectWarehouse< NodalConstraint > _nodal_constraints
NodalConstraint objects.
Definition: ConstraintWarehouse.h:85
ConstraintWarehouse::_displaced_node_face_constraints
std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > > _displaced_node_face_constraints
NodeFaceConstraint objects (displaced)
Definition: ConstraintWarehouse.h:91
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:333
ConstraintWarehouse::_displaced_node_elem_constraints
std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > > _displaced_node_elem_constraints
NodeElemConstraint objects.
Definition: ConstraintWarehouse.h:113
mesh
MeshBase & mesh
dynamic_pointer_cast
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
Definition: CastUniquePointer.h:21
FEProblemBase
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Definition: FEProblemBase.h:132
NodeFaceConstraint
A NodeFaceConstraint is used when you need to create constraints between two surfaces in a mesh...
Definition: NodeFaceConstraint.h:32
MooseMesh
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:88
InterfaceID
unsigned int InterfaceID
Definition: MooseTypes.h:206
ConstraintWarehouse::_element_constraints
std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > > _element_constraints
ElemElemConstraints (non-displaced)
Definition: ConstraintWarehouse.h:102
ConstraintWarehouse::_node_elem_constraints
std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > > _node_elem_constraints
NodeElemConstraint objects.
Definition: ConstraintWarehouse.h:109
ConstraintWarehouse::_displaced_element_constraints
std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > > _displaced_element_constraints
ElemElemConstraints (displaced)
Definition: ConstraintWarehouse.h:105
ConstraintWarehouse::_mortar_constraints
std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > > _mortar_constraints
Undisplaced MortarConstraints.
Definition: ConstraintWarehouse.h:95
NodeElemConstraintBase
A NodeElemConstraintBase is used when you need to create constraints between a secondary node and a p...
Definition: NodeElemConstraintBase.h:27
MooseObjectWarehouse::addObject
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
Definition: MooseObjectWarehouse.h:99
ConstraintWarehouse::_node_face_constraints
std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > > _node_face_constraints
NodeFaceConstraint objects (non-displaced)
Definition: ConstraintWarehouse.h:88

◆ checkThreadID()

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

Calls assert on thread id.

Definition at line 878 of file MooseObjectWarehouseBase.h.

Referenced by residualEnd().

879 {
880  mooseAssert(tid < _num_threads,
881  "Attempting to access a thread id ("
882  << tid << ") greater than the number allowed by the storage item ("
883  << _num_threads << ")");
884 }
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:208

◆ customSetup()

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

Definition at line 176 of file MooseObjectWarehouse.h.

177 {
178  checkThreadID(tid);
179  for (const auto & object : _active_objects[tid])
180  object->customSetup(exec_type);
181 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ 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 452 of file MooseObjectWarehouseBase.h.

453 {
454  checkThreadID(tid);
455  return _active_block_objects[tid];
456 }
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ getActiveBlockObjects() [2/2]

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

Definition at line 460 of file MooseObjectWarehouseBase.h.

461 {
462  checkThreadID(tid);
463  const auto iter = _active_block_objects[tid].find(id);
464  mooseAssert(iter != _active_block_objects[tid].end(),
465  "Unable to located active block objects for the given id: " << id << ".");
466  return iter->second;
467 }
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ getActiveBlocks()

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

Return a set of active SubdomainsIDs.

Definition at line 616 of file MooseObjectWarehouseBase.h.

617 {
618  checkThreadID(tid);
619  std::set<SubdomainID> ids;
620  for (const auto & object_pair : _active_block_objects[tid])
621  ids.insert(object_pair.first);
622  return ids;
623 }
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ 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 433 of file MooseObjectWarehouseBase.h.

434 {
435  checkThreadID(tid);
436  return _active_boundary_objects[tid];
437 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:226

◆ getActiveBoundaryObjects() [2/2]

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

Definition at line 441 of file MooseObjectWarehouseBase.h.

442 {
443  checkThreadID(tid);
444  const auto iter = _active_boundary_objects[tid].find(id);
445  mooseAssert(iter != _active_boundary_objects[tid].end(),
446  "Unable to located active boundary objects for the given id: " << id << ".");
447  return iter->second;
448 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:226

◆ 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().

174 {
175  std::map<unsigned int, MooseObjectWarehouse<ElemElemConstraint>>::const_iterator it, end_it;
176 
177  if (displaced)
178  {
179  it = _displaced_element_constraints.find(interface_id);
180  end_it = _displaced_element_constraints.end();
181  }
182 
183  else
184  {
185  it = _element_constraints.find(interface_id);
186  end_it = _element_constraints.end();
187  }
188 
189  mooseAssert(it != end_it,
190  "Unable to locate storage for ElemElemConstraint objects for the given interface id: "
191  << interface_id);
192  return it->second.getActiveObjects();
193 }
ConstraintWarehouse::_element_constraints
std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > > _element_constraints
ElemElemConstraints (non-displaced)
Definition: ConstraintWarehouse.h:102
ConstraintWarehouse::_displaced_element_constraints
std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > > _displaced_element_constraints
ElemElemConstraints (displaced)
Definition: ConstraintWarehouse.h:105

◆ 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().

147 {
148  std::map<std::pair<BoundaryID, BoundaryID>,
149  MooseObjectWarehouse<MortarConstraintBase>>::const_iterator it,
150  end_it;
151 
152  if (displaced)
153  {
154  it = _displaced_mortar_constraints.find(mortar_interface_key);
155  end_it = _displaced_mortar_constraints.end();
156  }
157  else
158  {
159  it = _mortar_constraints.find(mortar_interface_key);
160  end_it = _mortar_constraints.end();
161  }
162 
163  mooseAssert(
164  it != end_it,
165  "No MortarConstraints exist for the specified primary-secondary boundary pair, primary "
166  << mortar_interface_key.first << " and secondary " << mortar_interface_key.second);
167 
168  return it->second.getActiveObjects();
169 }
ConstraintWarehouse::_displaced_mortar_constraints
std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > > _displaced_mortar_constraints
Displaced MortarConstraints.
Definition: ConstraintWarehouse.h:99
MooseObjectWarehouse
A storage container for MooseObjects that inherit from SetupInterface.
Definition: ComputeDiracThread.h:22
ConstraintWarehouse::_mortar_constraints
std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > > _mortar_constraints
Undisplaced MortarConstraints.
Definition: ConstraintWarehouse.h:95

◆ 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().

109 {
110  return _nodal_constraints.getActiveObjects();
111 }
ConstraintWarehouse::_nodal_constraints
MooseObjectWarehouse< NodalConstraint > _nodal_constraints
NodalConstraint objects.
Definition: ConstraintWarehouse.h:85
MooseObjectWarehouseBase::getActiveObjects
const std::vector< std::shared_ptr< T > > & getActiveObjects(THREAD_ID tid=0) const
Retrieve complete vector to the active all/block/boundary restricted objects for a given thread...
Definition: MooseObjectWarehouseBase.h:425

◆ 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().

199 {
200  std::map<std::pair<SubdomainID, SubdomainID>,
201  MooseObjectWarehouse<NodeElemConstraintBase>>::const_iterator it,
202  end_it;
203 
204  if (displaced)
205  {
206  it = _displaced_node_elem_constraints.find(std::make_pair(secondary_id, primary_id));
207  end_it = _displaced_node_elem_constraints.end();
208  }
209  else
210  {
211  it = _node_elem_constraints.find(std::make_pair(secondary_id, primary_id));
212  end_it = _node_elem_constraints.end();
213  }
214 
215  mooseAssert(
216  it != end_it,
217  "Unable to locate storage for NodeElemConstraintBase objects for the given secondary and "
218  "primary id pair: ["
219  << secondary_id << ", " << primary_id << "]");
220  return it->second.getActiveObjects();
221 }
ConstraintWarehouse::_displaced_node_elem_constraints
std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > > _displaced_node_elem_constraints
NodeElemConstraint objects.
Definition: ConstraintWarehouse.h:113
MooseObjectWarehouse
A storage container for MooseObjects that inherit from SetupInterface.
Definition: ComputeDiracThread.h:22
ConstraintWarehouse::_node_elem_constraints
std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > > _node_elem_constraints
NodeElemConstraint objects.
Definition: ConstraintWarehouse.h:109

◆ 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().

115 {
116  std::map<BoundaryID, MooseObjectWarehouse<NodeFaceConstraint>>::const_iterator it, end_it;
117 
118  if (displaced)
119  {
120  it = _displaced_node_face_constraints.find(boundary_id);
121  end_it = _displaced_node_face_constraints.end();
122  }
123 
124  else
125  {
126  it = _node_face_constraints.find(boundary_id);
127  end_it = _node_face_constraints.end();
128  }
129 
130  mooseAssert(it != end_it,
131  "Unable to locate storage for NodeFaceConstraint objects for the given boundary id: "
132  << boundary_id);
133  return it->second.getActiveObjects();
134 }
ConstraintWarehouse::_displaced_node_face_constraints
std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > > _displaced_node_face_constraints
NodeFaceConstraint objects (displaced)
Definition: ConstraintWarehouse.h:91
ConstraintWarehouse::_node_face_constraints
std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > > _node_face_constraints
NodeFaceConstraint objects (non-displaced)
Definition: ConstraintWarehouse.h:88

◆ getActiveObject()

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

Definition at line 597 of file MooseObjectWarehouseBase.h.

598 {
599  checkThreadID(tid);
600  for (const auto & object : _active_objects[tid])
601  if (object->name() == name)
602  return object;
603  mooseError("Unable to locate active object: ", name, ".");
604 }
name
std::string name(const ElemQuality q)
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:333
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ 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
tidThe thread id to retrieve objects from

Definition at line 425 of file MooseObjectWarehouseBase.h.

426 {
427  checkThreadID(tid);
428  return _active_objects[tid];
429 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ 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.

146 {
147  checkThreadID(tid);
148  const auto iter = _variable_objects.find(variable_id);
149  mooseAssert(iter != _variable_objects.end(),
150  "Unable to locate variable kernels for the given variable id: " << variable_id
151  << ".");
152  return iter->second.getActiveBlockObjects(block_id, tid);
153 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouse< Constraint >::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< Constraint > > _variable_objects
Variable based storage.
Definition: MooseObjectWarehouse.h:88

◆ 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 406 of file MooseObjectWarehouseBase.h.

407 {
408  checkThreadID(tid);
409  return _all_block_objects[tid];
410 }
MooseObjectWarehouseBase< Constraint >::_all_block_objects
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > > _all_block_objects
Definition: MooseObjectWarehouseBase.h:217
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ getBlockObjects() [2/2]

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

Definition at line 414 of file MooseObjectWarehouseBase.h.

415 {
416  checkThreadID(tid);
417  const auto iter = _all_block_objects[tid].find(id);
418  mooseAssert(iter != _all_block_objects[tid].end(),
419  "Unable to located active block objects for the given id: " << id << ".");
420  return iter->second;
421 }
MooseObjectWarehouseBase< Constraint >::_all_block_objects
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > > _all_block_objects
Definition: MooseObjectWarehouseBase.h:217
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ 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 379 of file MooseObjectWarehouseBase.h.

380 {
381  checkThreadID(tid);
382  return _all_boundary_objects[tid];
383 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:223

◆ getBoundaryObjects() [2/2]

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

Definition at line 395 of file MooseObjectWarehouseBase.h.

396 {
397  checkThreadID(tid);
398  const auto iter = _all_boundary_objects[tid].find(id);
399  mooseAssert(iter != _all_boundary_objects[tid].end(),
400  "Unable to located active boundary objects for the given id: " << id << ".");
401  return iter->second;
402 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:223

◆ getObject()

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

Definition at line 586 of file MooseObjectWarehouseBase.h.

587 {
588  checkThreadID(tid);
589  for (const auto & object : _all_objects[tid])
590  if (object->name() == name)
591  return object;
592  mooseError("Unable to locate object: ", name, ".");
593 }
name
std::string name(const ElemQuality q)
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:333
MooseObjectWarehouseBase< Constraint >::_all_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:211
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ 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
tidThe thread id to retrieve objects from

Definition at line 371 of file MooseObjectWarehouseBase.h.

372 {
373  checkThreadID(tid);
374  return _all_objects[tid];
375 }
MooseObjectWarehouseBase< Constraint >::_all_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:211
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ 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 608 of file MooseObjectWarehouseBase.h.

610 {
611  return libmesh_map_find(_all_variable_objects[tid], var_name);
612 }
MooseObjectWarehouseBase< Constraint >::_all_variable_objects
std::vector< std::map< VariableName, std::vector< std::shared_ptr< Constraint > > > > _all_variable_objects
All objects with a certain variable selected, as the &#39;variable&#39; parameter.
Definition: MooseObjectWarehouseBase.h:229

◆ hasActiveBlockObjects() [1/2]

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

Definition at line 535 of file MooseObjectWarehouseBase.h.

536 {
537  checkThreadID(tid);
538  bool has_active_block_objects = false;
539  for (const auto & object_pair : _active_block_objects[tid])
540  has_active_block_objects |= !(object_pair.second.empty());
541  return has_active_block_objects;
542 }
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ hasActiveBlockObjects() [2/2]

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

Definition at line 546 of file MooseObjectWarehouseBase.h.

547 {
548  checkThreadID(tid);
549  const auto iter = _active_block_objects[tid].find(id);
550  return iter != _active_block_objects[tid].end();
551 }
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ hasActiveBoundaryObjects() [1/2]

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

Definition at line 555 of file MooseObjectWarehouseBase.h.

556 {
557  checkThreadID(tid);
558  bool has_active_boundary_objects = false;
559  for (const auto & object_pair : _active_boundary_objects[tid])
560  has_active_boundary_objects |= !(object_pair.second.empty());
561  return has_active_boundary_objects;
562 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:226

◆ hasActiveBoundaryObjects() [2/2]

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

Definition at line 566 of file MooseObjectWarehouseBase.h.

567 {
568  checkThreadID(tid);
569  const auto iter = _active_boundary_objects[tid].find(id);
570  return iter != _active_boundary_objects[tid].end();
571 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:226

◆ 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().

232 {
233  std::map<unsigned int, MooseObjectWarehouse<ElemElemConstraint>>::const_iterator it, end_it;
234 
235  if (displaced)
236  {
237  it = _displaced_element_constraints.find(interface_id);
238  end_it = _displaced_element_constraints.end();
239  }
240 
241  else
242  {
243  it = _element_constraints.find(interface_id);
244  end_it = _element_constraints.end();
245  }
246 
247  return (it != end_it && it->second.hasActiveObjects());
248 }
ConstraintWarehouse::_element_constraints
std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > > _element_constraints
ElemElemConstraints (non-displaced)
Definition: ConstraintWarehouse.h:102
ConstraintWarehouse::_displaced_element_constraints
std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > > _displaced_element_constraints
ElemElemConstraints (displaced)
Definition: ConstraintWarehouse.h:105

◆ 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().

139 {
140  const auto & constraints = displaced ? _displaced_mortar_constraints : _mortar_constraints;
141  return constraints.find(mortar_interface_key) != constraints.end();
142 }
ConstraintWarehouse::_displaced_mortar_constraints
std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > > _displaced_mortar_constraints
Displaced MortarConstraints.
Definition: ConstraintWarehouse.h:99
ConstraintWarehouse::_mortar_constraints
std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > > _mortar_constraints
Undisplaced MortarConstraints.
Definition: ConstraintWarehouse.h:95

◆ 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().

225 {
226  return _nodal_constraints.hasActiveObjects();
227 }
ConstraintWarehouse::_nodal_constraints
MooseObjectWarehouse< NodalConstraint > _nodal_constraints
NodalConstraint objects.
Definition: ConstraintWarehouse.h:85
MooseObjectWarehouseBase::hasActiveObjects
bool hasActiveObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:479

◆ 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().

274 {
275  std::map<std::pair<SubdomainID, SubdomainID>,
276  MooseObjectWarehouse<NodeElemConstraintBase>>::const_iterator it,
277  end_it;
278 
279  if (displaced)
280  {
281  it = _displaced_node_elem_constraints.find(std::make_pair(secondary_id, primary_id));
282  end_it = _displaced_node_elem_constraints.end();
283  }
284 
285  else
286  {
287  it = _node_elem_constraints.find(std::make_pair(secondary_id, primary_id));
288  end_it = _node_elem_constraints.end();
289  }
290 
291  return (it != end_it && it->second.hasActiveObjects());
292 }
ConstraintWarehouse::_displaced_node_elem_constraints
std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > > _displaced_node_elem_constraints
NodeElemConstraint objects.
Definition: ConstraintWarehouse.h:113
MooseObjectWarehouse
A storage container for MooseObjects that inherit from SetupInterface.
Definition: ComputeDiracThread.h:22
ConstraintWarehouse::_node_elem_constraints
std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > > _node_elem_constraints
NodeElemConstraint objects.
Definition: ConstraintWarehouse.h:109

◆ 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().

252 {
253  std::map<BoundaryID, MooseObjectWarehouse<NodeFaceConstraint>>::const_iterator it, end_it;
254 
255  if (displaced)
256  {
257  it = _displaced_node_face_constraints.find(boundary_id);
258  end_it = _displaced_node_face_constraints.end();
259  }
260 
261  else
262  {
263  it = _node_face_constraints.find(boundary_id);
264  end_it = _node_face_constraints.end();
265  }
266 
267  return (it != end_it && it->second.hasActiveObjects());
268 }
ConstraintWarehouse::_displaced_node_face_constraints
std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > > _displaced_node_face_constraints
NodeFaceConstraint objects (displaced)
Definition: ConstraintWarehouse.h:91
ConstraintWarehouse::_node_face_constraints
std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > > _node_face_constraints
NodeFaceConstraint objects (non-displaced)
Definition: ConstraintWarehouse.h:88

◆ 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 575 of file MooseObjectWarehouseBase.h.

576 {
577  checkThreadID(tid);
578  for (const auto & object : _active_objects[tid])
579  if (object->name() == name)
580  return true;
581  return false;
582 }
name
std::string name(const ElemQuality q)
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ hasActiveObjects()

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

Definition at line 479 of file MooseObjectWarehouseBase.h.

480 {
481  checkThreadID(tid);
482  return !_active_objects[tid].empty();
483 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ 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.

136 {
137  auto iter = _variable_objects.find(variable_id);
138  return (iter != _variable_objects.end() && iter->second.hasActiveBlockObjects(block_id, tid));
139 }
MooseObjectWarehouse< Constraint >::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< Constraint > > _variable_objects
Variable based storage.
Definition: MooseObjectWarehouse.h:88

◆ hasBoundaryObjects()

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

Definition at line 387 of file MooseObjectWarehouseBase.h.

388 {
389  checkThreadID(tid);
390  return _all_boundary_objects[tid].find(id) != _all_boundary_objects[tid].end();
391 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:223

◆ hasObjects()

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

Convenience functions for determining if objects exist.

Definition at line 471 of file MooseObjectWarehouseBase.h.

472 {
473  checkThreadID(tid);
474  return !_all_objects[tid].empty();
475 }
MooseObjectWarehouseBase< Constraint >::_all_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:211
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ hasObjectsForVariable()

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

Definition at line 487 of file MooseObjectWarehouseBase.h.

489 {
490  checkThreadID(tid);
491  return _all_variable_objects[tid].count(var_name);
492 }
MooseObjectWarehouseBase< Constraint >::_all_variable_objects
std::vector< std::map< VariableName, std::vector< std::shared_ptr< Constraint > > > > _all_variable_objects
All objects with a certain variable selected, as the &#39;variable&#39; parameter.
Definition: MooseObjectWarehouseBase.h:229
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ 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_namename of the variable
blocksblocks to consider
blocks_coveredsubset of blocks for which there is an object

Definition at line 496 of file MooseObjectWarehouseBase.h.

500 {
501  checkThreadID(tid);
502  blocks_covered.clear();
503  if (!hasObjectsForVariable(var_name, tid))
504  return false;
505 
506  // Check block restriction as a whole
507  for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
508  {
509  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
510  if (blk && blk->hasBlocks(blocks))
511  {
512  blocks_covered = blocks;
513  return true;
514  }
515  }
516  // No object has all the blocks, but one might overlap, which could be troublesome.
517  // We'll keep track of which blocks are covered in case several overlap
518  for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
519  {
520  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
521  if (blk)
522  for (const auto & block : blocks)
523  if (blk->hasBlocks(block))
524  blocks_covered.insert(block);
525  }
526  // No overlap at all
527  if (blocks_covered.empty())
528  return false;
529 
530  return (blocks == blocks_covered);
531 }
blocks
char ** blocks
Definition: PetscDMMoose.C:1733
MooseObjectWarehouseBase< Constraint >::_all_variable_objects
std::vector< std::map< VariableName, std::vector< std::shared_ptr< Constraint > > > > _all_variable_objects
All objects with a certain variable selected, as the &#39;variable&#39; parameter.
Definition: MooseObjectWarehouseBase.h:229
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
dynamic_pointer_cast
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
Definition: CastUniquePointer.h:21
MooseObjectWarehouseBase< Constraint >::hasObjectsForVariable
bool hasObjectsForVariable(const VariableName &var_name, THREAD_ID tid) const
Definition: MooseObjectWarehouseBase.h:487
BlockRestrictable
An interface that restricts an object to subdomains via the &#39;blocks&#39; input parameter.
Definition: BlockRestrictable.h:57

◆ 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.

126 {
127  auto iter = _variable_objects.find(variable_id);
128  return (iter != _variable_objects.end() && iter->second.hasObjects(tid));
129 }
MooseObjectWarehouse< Constraint >::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< Constraint > > _variable_objects
Variable based storage.
Definition: MooseObjectWarehouse.h:88

◆ 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.

158 {
159  checkThreadID(tid);
160  // Initial Setup should be called on all objects because they may become active later
161  for (const auto & object : _all_objects[tid])
162  object->initialSetup();
163 }
MooseObjectWarehouseBase< Constraint >::_all_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:211
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ jacobianSetup()

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

Definition at line 207 of file MooseObjectWarehouse.h.

208 {
209  checkThreadID(tid);
210  for (const auto & object : _active_objects[tid])
211  object->jacobianSetup();
212 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ numThreads()

THREAD_ID MooseObjectWarehouseBase< Constraint >::numThreads ( ) const
inlineinherited

Return the number of threads.

Definition at line 196 of file MooseObjectWarehouseBase.h.

196 { 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:208

◆ residualEnd()

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

Definition at line 358 of file ConstraintWarehouse.C.

Referenced by NonlinearSystemBase::computeResidualInternal().

359 {
360  checkThreadID(tid);
361  for (const auto & object : _active_objects[tid])
362  object->residualEnd();
363 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ residualSetup()

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

Definition at line 216 of file MooseObjectWarehouse.h.

217 {
218  checkThreadID(tid);
219  for (const auto & object : _active_objects[tid])
220  object->residualSetup();
221 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ 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 289 of file MooseObjectWarehouseBase.h.

290 {
291  checkThreadID(tid);
292  return _all_objects[tid].size();
293 }
MooseObjectWarehouseBase< Constraint >::_all_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:211
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ sort()

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

Sort the objects using the DependencyResolver.

Definition at line 656 of file MooseObjectWarehouseBase.h.

657 {
658  checkThreadID(tid);
659 
660  for (auto & object_pair : _all_block_objects[tid])
661  sortHelper(object_pair.second);
662 
663  for (auto & object_pair : _all_boundary_objects[tid])
664  sortHelper(object_pair.second);
665 
666  sortHelper(_all_objects[tid]);
667 
668  // The active lists now must be update to reflect the order changes
669  updateActive(tid);
670 }
MooseObjectWarehouseBase< Constraint >::_all_block_objects
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > > _all_block_objects
Definition: MooseObjectWarehouseBase.h:217
MooseObjectWarehouseBase< Constraint >::_all_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:211
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::sortHelper
static void sortHelper(std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for sorting vectors of objects.
Definition: MooseObjectWarehouseBase.h:858
MooseObjectWarehouseBase< Constraint >::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:223
MooseObjectWarehouseBase< Constraint >::updateActive
virtual void updateActive(THREAD_ID tid=0)
Updates the active objects storage.
Definition: MooseObjectWarehouseBase.h:627

◆ sortHelper()

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

Helper method for sorting vectors of objects.

Definition at line 858 of file MooseObjectWarehouseBase.h.

859 {
860  // Do nothing if the vector is empty
861  if (objects.empty())
862  return;
863 
864  try
865  {
866  // Sort based on dependencies
867  DependencyResolverInterface::sort<std::shared_ptr<T>>(objects);
868  }
869  catch (CyclicDependencyException<std::shared_ptr<T>> & e)
870  {
871  DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<T>>(
872  e, "Cyclic dependency detected in object ordering");
873  }
874 }

◆ 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().

321 {
322  // Loop over undisplaced
323  for (const auto & pr : _mortar_constraints)
324  {
325  const auto & objects = pr.second.getActiveObjects();
326  for (const auto & mc : objects)
327  {
328  const MooseVariableFEBase * lm_var = mc->variablePtr();
329  if (lm_var)
330  unique_variables.insert(lm_var->name());
331 
332  // Mortar constraints will cover primary and secondary subdomains regardless of whether we
333  // have a Lagrange multiplier associated.
334  subdomains_covered.insert(mc->primarySubdomain());
335  subdomains_covered.insert(mc->secondarySubdomain());
336  }
337  }
338 
339  // Loop over displaced
340  for (const auto & pr : _displaced_mortar_constraints)
341  {
342  const auto & objects = pr.second.getActiveObjects();
343  for (const auto & mc : objects)
344  {
345  const MooseVariableFEBase * lm_var = mc->variablePtr();
346  if (lm_var)
347  unique_variables.insert(lm_var->name());
348 
349  // Mortar constraints will cover primary and secondary subdomains regardless of whether we
350  // have a Lagrange multiplier associated.
351  subdomains_covered.insert(mc->primarySubdomain());
352  subdomains_covered.insert(mc->secondarySubdomain());
353  }
354  }
355 }
ConstraintWarehouse::_displaced_mortar_constraints
std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > > _displaced_mortar_constraints
Displaced MortarConstraints.
Definition: ConstraintWarehouse.h:99
MooseVariableFieldBase
This class provides an interface for common operations on field variables of both FE and FV types wit...
Definition: MooseVariableFieldBase.h:29
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:99
MooseVariableFieldBase::insert
virtual void insert(libMesh::NumericVector< libMesh::Number > &vector)=0
Insert the currently cached degree of freedom values into the provided vector.
ConstraintWarehouse::_mortar_constraints
std::map< std::pair< BoundaryID, BoundaryID >, MooseObjectWarehouse< MortarConstraintBase > > _mortar_constraints
Undisplaced MortarConstraints.
Definition: ConstraintWarehouse.h:95

◆ subdomainSetup() [1/2]

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

Definition at line 198 of file MooseObjectWarehouse.h.

199 {
200  checkThreadID(tid);
201  for (const auto & object : _active_objects[tid])
202  object->subdomainSetup();
203 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ subdomainSetup() [2/2]

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

Definition at line 185 of file MooseObjectWarehouse.h.

186 {
187  checkThreadID(tid);
188  if (hasActiveBlockObjects(id, tid))
189  {
190  const auto & objects = getActiveBlockObjects(id, tid);
191  for (const auto & object : objects)
192  object->subdomainSetup();
193  }
194 }
MooseObjectWarehouseBase< Constraint >::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:535
MooseObjectWarehouseBase< Constraint >::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:452
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878

◆ timestepSetup()

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

Definition at line 167 of file MooseObjectWarehouse.h.

168 {
169  checkThreadID(tid);
170  for (const auto & object : _active_objects[tid])
171  object->timestepSetup();
172 }
MooseObjectWarehouseBase< Constraint >::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:878
MooseObjectWarehouseBase< Constraint >::_active_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:214

◆ 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().

296 {
297  MooseObjectWarehouse<Constraint>::updateActive();
298  _nodal_constraints.updateActive();
299 
300  for (auto & it : _node_face_constraints)
301  it.second.updateActive();
302 
303  for (auto & it : _displaced_node_face_constraints)
304  it.second.updateActive();
305 
306  // FIXME: We call updateActive() on the NodeFaceConstraints again?
307  for (auto & it : _node_face_constraints)
308  it.second.updateActive();
309 
310  for (auto & it : _element_constraints)
311  it.second.updateActive();
312 
313  for (auto & it : _node_elem_constraints)
314  it.second.updateActive();
315 }
ConstraintWarehouse::_nodal_constraints
MooseObjectWarehouse< NodalConstraint > _nodal_constraints
NodalConstraint objects.
Definition: ConstraintWarehouse.h:85
ConstraintWarehouse::_displaced_node_face_constraints
std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > > _displaced_node_face_constraints
NodeFaceConstraint objects (displaced)
Definition: ConstraintWarehouse.h:91
ConstraintWarehouse::_element_constraints
std::map< unsigned int, MooseObjectWarehouse< ElemElemConstraint > > _element_constraints
ElemElemConstraints (non-displaced)
Definition: ConstraintWarehouse.h:102
ConstraintWarehouse::_node_elem_constraints
std::map< std::pair< SubdomainID, SubdomainID >, MooseObjectWarehouse< NodeElemConstraintBase > > _node_elem_constraints
NodeElemConstraint objects.
Definition: ConstraintWarehouse.h:109
MooseObjectWarehouse::updateActive
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
Definition: MooseObjectWarehouse.h:225
ConstraintWarehouse::_node_face_constraints
std::map< BoundaryID, MooseObjectWarehouse< NodeFaceConstraint > > _node_face_constraints
NodeFaceConstraint objects (non-displaced)
Definition: ConstraintWarehouse.h:88

◆ 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 642 of file MooseObjectWarehouseBase.h.

644 {
645  // Clear the active list
646  active.clear();
647 
648  std::copy_if(all.begin(),
649  all.end(),
650  std::back_inserter(active),
651  [](const std::shared_ptr<T> & object) { return object->enabled(); });
652 }

◆ updateBlockFEVariableCoupledVectorTagDependency()

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

Update FE variable coupleable vector tag vector.

Definition at line 735 of file MooseObjectWarehouseBase.h.

737 {
738  if (hasActiveBlockObjects(id, tid))
739  updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
740  getActiveBlockObjects(id, tid));
741 }
MooseObjectWarehouseBase< Constraint >::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:535
MooseObjectWarehouseBase< Constraint >::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:452
MooseObjectWarehouseBase< Constraint >::updateFEVariableCoupledVectorTagDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:755

◆ updateBlockMatPropDependency()

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

Definition at line 780 of file MooseObjectWarehouseBase.h.

784 {
785  if (hasActiveBlockObjects(id, tid))
786  updateMatPropDependencyHelper(needed_mat_props, getActiveBlockObjects(id, tid));
787 }
MooseObjectWarehouseBase< Constraint >::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:535
MooseObjectWarehouseBase< Constraint >::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:452
MooseObjectWarehouseBase< Constraint >::updateMatPropDependencyHelper
static void updateMatPropDependencyHelper(std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for updating material property dependency vector.
Definition: MooseObjectWarehouseBase.h:812

◆ updateBlockVariableDependency()

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

Definition at line 683 of file MooseObjectWarehouseBase.h.

687 {
688  if (hasActiveBlockObjects(id, tid))
689  updateVariableDependencyHelper(needed_moose_vars, getActiveBlockObjects(id, tid));
690 }
MooseObjectWarehouseBase< Constraint >::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:535
MooseObjectWarehouseBase< Constraint >::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< Constraint > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:452
MooseObjectWarehouseBase< Constraint >::updateVariableDependencyHelper
static void updateVariableDependencyHelper(std::set< MooseVariableFieldBase * > &needed_moose_vars, const std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for updating variable dependency vector.
Definition: MooseObjectWarehouseBase.h:718

◆ updateBoundaryFEVariableCoupledVectorTagDependency()

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

Definition at line 745 of file MooseObjectWarehouseBase.h.

747 {
748  if (hasActiveBoundaryObjects(id, tid))
749  updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
750  getActiveBoundaryObjects(id, tid));
751 }
MooseObjectWarehouseBase< Constraint >::updateFEVariableCoupledVectorTagDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:755
MooseObjectWarehouseBase< Constraint >::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:555
MooseObjectWarehouseBase< Constraint >::getActiveBoundaryObjects
const std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:433

◆ updateBoundaryMatPropDependency() [1/2]

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

Definition at line 791 of file MooseObjectWarehouseBase.h.

793 {
794  if (hasActiveBoundaryObjects(tid))
795  for (auto & active_bnd_object : _active_boundary_objects[tid])
796  updateMatPropDependencyHelper(needed_mat_props, active_bnd_object.second);
797 }
MooseObjectWarehouseBase< Constraint >::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:555
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:226
MooseObjectWarehouseBase< Constraint >::updateMatPropDependencyHelper
static void updateMatPropDependencyHelper(std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for updating material property dependency vector.
Definition: MooseObjectWarehouseBase.h:812

◆ updateBoundaryMatPropDependency() [2/2]

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

Definition at line 801 of file MooseObjectWarehouseBase.h.

805 {
806  if (hasActiveBoundaryObjects(id, tid))
807  updateMatPropDependencyHelper(needed_mat_props, getActiveBoundaryObjects(id, tid));
808 }
MooseObjectWarehouseBase< Constraint >::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:555
MooseObjectWarehouseBase< Constraint >::updateMatPropDependencyHelper
static void updateMatPropDependencyHelper(std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for updating material property dependency vector.
Definition: MooseObjectWarehouseBase.h:812
MooseObjectWarehouseBase< Constraint >::getActiveBoundaryObjects
const std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:433

◆ updateBoundaryVariableDependency() [1/2]

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

Definition at line 694 of file MooseObjectWarehouseBase.h.

696 {
697  if (hasActiveBoundaryObjects(tid))
698  {
699  typename std::map<BoundaryID, std::vector<std::shared_ptr<T>>>::const_iterator it;
700  for (const auto & object_pair : _active_boundary_objects[tid])
701  updateVariableDependencyHelper(needed_moose_vars, object_pair.second);
702  }
703 }
MooseObjectWarehouseBase< Constraint >::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:555
MooseObjectWarehouseBase< Constraint >::_active_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)
Definition: MooseObjectWarehouseBase.h:226
MooseObjectWarehouseBase< Constraint >::updateVariableDependencyHelper
static void updateVariableDependencyHelper(std::set< MooseVariableFieldBase * > &needed_moose_vars, const std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for updating variable dependency vector.
Definition: MooseObjectWarehouseBase.h:718

◆ updateBoundaryVariableDependency() [2/2]

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

Definition at line 707 of file MooseObjectWarehouseBase.h.

711 {
712  if (hasActiveBoundaryObjects(id, tid))
713  updateVariableDependencyHelper(needed_moose_vars, getActiveBoundaryObjects(id, tid));
714 }
MooseObjectWarehouseBase< Constraint >::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:555
MooseObjectWarehouseBase< Constraint >::updateVariableDependencyHelper
static void updateVariableDependencyHelper(std::set< MooseVariableFieldBase * > &needed_moose_vars, const std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for updating variable dependency vector.
Definition: MooseObjectWarehouseBase.h:718
MooseObjectWarehouseBase< Constraint >::getActiveBoundaryObjects
const std::map< BoundaryID, std::vector< std::shared_ptr< Constraint > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:433

◆ 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 755 of file MooseObjectWarehouseBase.h.

757 {
758  for (const auto & object : objects)
759  {
760  auto c = dynamic_cast<const Coupleable *>(object.get());
761  if (c)
762  {
763  const auto & tag_deps = c->getFEVariableCoupleableVectorTags();
764  needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
765  }
766  }
767 }
Coupleable
Interface for objects that needs coupling capabilities.
Definition: Coupleable.h:45
Coupleable::getFEVariableCoupleableVectorTags
std::set< TagID > & getFEVariableCoupleableVectorTags()
Definition: Coupleable.h:106

◆ updateMatPropDependency()

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

Update material property dependency vector.

Definition at line 771 of file MooseObjectWarehouseBase.h.

773 {
774  if (hasActiveObjects(tid))
775  updateMatPropDependencyHelper(needed_mat_props, _all_objects[tid]);
776 }
MooseObjectWarehouseBase< Constraint >::_all_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:211
MooseObjectWarehouseBase< Constraint >::updateMatPropDependencyHelper
static void updateMatPropDependencyHelper(std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for updating material property dependency vector.
Definition: MooseObjectWarehouseBase.h:812

◆ updateMatPropDependencyHelper()

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

Helper method for updating material property dependency vector.

Definition at line 812 of file MooseObjectWarehouseBase.h.

815 {
816  for (auto & object : objects)
817  {
818  auto c = dynamic_cast<const MaterialPropertyInterface *>(object.get());
819  if (c)
820  {
821  auto & mp_deps = c->getMatPropDependencies();
822  needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
823  }
824  }
825 }
MaterialPropertyInterface::getMatPropDependencies
virtual const std::unordered_set< unsigned int > & getMatPropDependencies() const
Retrieve the set of material properties that this object depends on.
Definition: MaterialPropertyInterface.h:328
MaterialPropertyInterface
An interface for accessing Materials.
Definition: MaterialPropertyInterface.h:65

◆ updateVariableDependency()

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

Update variable dependency vector.

Definition at line 674 of file MooseObjectWarehouseBase.h.

676 {
677  if (hasActiveObjects(tid))
678  updateVariableDependencyHelper(needed_moose_vars, _all_objects[tid]);
679 }
MooseObjectWarehouseBase< Constraint >::_all_objects
std::vector< std::vector< std::shared_ptr< Constraint > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:211
MooseObjectWarehouseBase< Constraint >::updateVariableDependencyHelper
static void updateVariableDependencyHelper(std::set< MooseVariableFieldBase * > &needed_moose_vars, const std::vector< std::shared_ptr< Constraint >> &objects)
Helper method for updating variable dependency vector.
Definition: MooseObjectWarehouseBase.h:718

◆ 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 718 of file MooseObjectWarehouseBase.h.

721 {
722  for (const auto & object : objects)
723  {
724  auto c = dynamic_cast<const MooseVariableDependencyInterface *>(object.get());
725  if (c)
726  {
727  const auto & mv_deps = c->getMooseVariableDependencies();
728  needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
729  }
730  }
731 }
MooseVariableDependencyInterface::getMooseVariableDependencies
const std::set< MooseVariableFieldBase * > & getMooseVariableDependencies() const
Retrieve the set of MooseVariableFieldBase that this object depends on.
Definition: MooseVariableDependencyInterface.h:35

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 220 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 226 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 214 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 217 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 223 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 211 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 229 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 208 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:
Generated on Wed Aug 20 2025 08:20:27 for https://mooseframework.inl.gov by   doxygen 1.8.14