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

Class for threaded computation of UserObjects. More...

#include <ComputeUserObjectsThread.h>

Inheritance diagram for ComputeUserObjectsThread:
[legend]

Public Member Functions

 ComputeUserObjectsThread (FEProblemBase &problem, const TheWarehouse::Query &query)
 
 ComputeUserObjectsThread (ComputeUserObjectsThread &x, Threads::split)
 
virtual ~ComputeUserObjectsThread ()
 
virtual void onElement (const Elem *elem) override
 Assembly of the element (not including surface assembly) More...
 
virtual void onBoundary (const Elem *elem, unsigned int side, BoundaryID bnd_id, const Elem *lower_d_elem=nullptr) override
 Called when doing boundary assembling. More...
 
virtual void onInternalSide (const Elem *elem, unsigned int side) override
 Called when doing internal edge assembling. More...
 
virtual void onExternalSide (const Elem *elem, unsigned int side) override
 Called when iterating over external sides (no side neighbor) More...
 
virtual void onInterface (const Elem *elem, unsigned int side, BoundaryID bnd_id) override
 Called when doing interface assembling. More...
 
virtual void post () override
 Called after the element range loop. More...
 
virtual void subdomainChanged () override
 Called every time the current subdomain changes (i.e. More...
 
void join (const ComputeUserObjectsThread &)
 
virtual void caughtMooseException (MooseException &e) override
 Called if a MooseException is caught anywhere during the computation. More...
 
virtual bool keepGoing () override
 Whether or not the loop should continue. More...
 
virtual void preElement (const Elem *elem) override
 Called before the element assembly. More...
 
virtual void preInternalSide (const Elem *elem, unsigned int side) override
 Called before evaluations on an element internal side. More...
 
virtual void preBoundary (const Elem *elem, unsigned int side, BoundaryID bnd_id, const Elem *lower_d_elem=nullptr) override
 Called before the boundary assembly. More...
 
virtual void neighborSubdomainChanged () override
 Called every time the neighbor subdomain changes (i.e. More...
 
virtual void operator() (const ConstElemRange &range, bool bypass_threading=false)
 
virtual void pre ()
 Called before the element range loop. More...
 
virtual void postElement (const Elem *elem)
 Called after the element assembly is done (including surface assembling) More...
 
virtual void postInternalSide (const Elem *elem, unsigned int side)
 Called after evaluations on an element internal side. More...
 

Protected Member Functions

void printGeneralExecutionInformation () const override
 Print general information about the loop, like the ordering of class of objects. More...
 
void printBlockExecutionInformation () const override
 Print information about the loop, mostly order of execution of particular objects. More...
 
template<typename T >
void printVectorOrdering (std::vector< T *> uos, const std::string &name) const
 Format output of vector of UOs. More...
 
void prepareElement (const Elem *elem)
 
void clearVarsAndMaterials ()
 
void printExecutionOrdering (const std::vector< T * > &objs, const bool print_header=true, const std::string &line_prefix="[DBG]") const
 Routine to output the ordering of objects within a vector of pointers to these objects. More...
 
void printExecutionOrdering (const std::vector< std::shared_ptr< T >> &objs_ptrs, const bool print_header=true, const std::string &line_prefix="[DBG]") const
 
virtual void printBoundaryExecutionInformation (const unsigned int) const
 Print information about the particular ordering of objects on each boundary. More...
 
void resetExecPrintedSets () const
 Resets the set of blocks and boundaries visited. More...
 
virtual bool shouldComputeInternalSide (const Elem &elem, const Elem &neighbor) const
 Whether to compute the internal side for the provided element-neighbor pair. More...
 

Protected Attributes

FEProblemBase_fe_problem
 
MooseMesh_mesh
 
THREAD_ID _tid
 
SubdomainID _subdomain
 The subdomain for the current element. More...
 
SubdomainID _old_subdomain
 The subdomain for the last element. More...
 
SubdomainID _neighbor_subdomain
 The subdomain for the current neighbor. More...
 
SubdomainID _old_neighbor_subdomain
 The subdomain for the last neighbor. More...
 
std::set< SubdomainID_blocks_exec_printed
 Keep track of which blocks were visited. More...
 
std::set< BoundaryID_boundaries_exec_printed
 Keep track of which boundaries were visited. More...
 

Private Member Functions

template<typename T >
void querySubdomain (Interfaces iface, std::vector< T > &results)
 
template<typename T >
void queryBoundary (Interfaces iface, BoundaryID bnd, std::vector< T > &results)
 

Private Attributes

const TheWarehouse::Query _query
 
TheWarehouse::QueryCache< AttribThread, AttribSubdomains, AttribInterfaces_query_subdomain
 
TheWarehouse::QueryCache< AttribThread, AttribBoundaries, AttribInterfaces_query_boundary
 
std::vector< InternalSideUserObject * > _internal_side_objs
 
std::vector< InterfaceUserObject * > _interface_user_objects
 
std::vector< ElementUserObject * > _element_objs
 
std::vector< ShapeElementUserObject * > _shape_element_objs
 
std::vector< DomainUserObject * > _domain_objs
 
std::vector< DomainUserObject * > _all_domain_objs
 
AuxiliarySystem_aux_sys
 

Detailed Description

Class for threaded computation of UserObjects.

Definition at line 37 of file ComputeUserObjectsThread.h.

Constructor & Destructor Documentation

◆ ComputeUserObjectsThread() [1/2]

ComputeUserObjectsThread::ComputeUserObjectsThread ( FEProblemBase problem,
const TheWarehouse::Query query 
)

Definition at line 29 of file ComputeUserObjectsThread.C.

32  _query(query),
35  _aux_sys(problem.getAuxiliarySystem())
36 {
37 }
TheWarehouse::QueryCache< AttribThread, AttribSubdomains, AttribInterfaces > _query_subdomain
TheWarehouse::QueryCache< AttribThread, AttribBoundaries, AttribInterfaces > _query_boundary
const TheWarehouse::Query _query
AuxiliarySystem & getAuxiliarySystem()

◆ ComputeUserObjectsThread() [2/2]

ComputeUserObjectsThread::ComputeUserObjectsThread ( ComputeUserObjectsThread x,
Threads::split   
)

Definition at line 40 of file ComputeUserObjectsThread.C.

42  _query(x._query),
46 {
47 }
TheWarehouse::QueryCache< AttribThread, AttribSubdomains, AttribInterfaces > _query_subdomain
TheWarehouse::QueryCache< AttribThread, AttribBoundaries, AttribInterfaces > _query_boundary
FEProblemBase & _fe_problem
const TheWarehouse::Query _query

◆ ~ComputeUserObjectsThread()

ComputeUserObjectsThread::~ComputeUserObjectsThread ( )
virtual

Definition at line 49 of file ComputeUserObjectsThread.C.

49 {}

Member Function Documentation

◆ caughtMooseException()

void ThreadedElementLoop< ConstElemRange >::caughtMooseException ( MooseException e)
overridevirtualinherited

Called if a MooseException is caught anywhere during the computation.

The single input parameter taken is a MooseException object.

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 105 of file ThreadedElementLoop.h.

Referenced by ComputeJacobianForScalingThread::operator()().

106 {
107  Threads::spin_mutex::scoped_lock lock(threaded_element_mutex);
108 
109  std::string what(e.what());
111 }
virtual const char * what() const
Get out the error message.
virtual void setException(const std::string &message)
Set an exception, which is stored at this point by toggling a member variable in this class...
static Threads::spin_mutex threaded_element_mutex
This mutex is used by all derived classes of the ThreadedElementLoop.

◆ clearVarsAndMaterials()

void ThreadedElementLoop< ConstElemRange >::clearVarsAndMaterials ( )
protectedinherited

Definition at line 195 of file ThreadedElementLoop.h.

Referenced by NonlinearThread::post().

196 {
199 }
void clearActiveMaterialProperties(const THREAD_ID tid)
Clear the active material properties.
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid) override
Clear the active elemental MooseVariableFEBase.

◆ join()

void ComputeUserObjectsThread::join ( const ComputeUserObjectsThread )

Definition at line 328 of file ComputeUserObjectsThread.C.

329 {
330 }

◆ keepGoing()

virtual bool ThreadedElementLoop< ConstElemRange >::keepGoing ( )
inlineoverridevirtualinherited

Whether or not the loop should continue.

Returns
true to keep going, false to stop.

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 45 of file ThreadedElementLoop.h.

Referenced by ComputeJacobianForScalingThread::operator()().

45 { return !_fe_problem.hasException(); }
virtual bool hasException()
Whether or not an exception has occurred.

◆ neighborSubdomainChanged()

void ThreadedElementLoop< ConstElemRange >::neighborSubdomainChanged ( )
overridevirtualinherited

Called every time the neighbor subdomain changes (i.e.

the subdomain of this neighbor is not the same as the subdomain of the last neighbor). Beware of over-using this! You might think that you can do some expensive stuff in here and get away with it... but there are applications that have TONS of subdomains....

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 139 of file ThreadedElementLoop.h.

140 {
143 }
Base class for assembly-like calculations.
virtual void neighborSubdomainSetup(SubdomainID subdomain, const THREAD_ID tid)

◆ onBoundary()

void ComputeUserObjectsThread::onBoundary ( const Elem *  elem,
unsigned int  side,
BoundaryID  bnd_id,
const Elem *  lower_d_elem = nullptr 
)
overridevirtual

Called when doing boundary assembling.

Parameters
elem- The element we are checking is on the boundary.
side- The side of the element in question.
bnd_id- ID of the boundary we are at
lower_d_elem- Lower dimensional element (e.g. Mortar)

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 165 of file ComputeUserObjectsThread.C.

169 {
170  std::vector<UserObject *> userobjs;
171  queryBoundary(Interfaces::SideUserObject, bnd_id, userobjs);
172  if (userobjs.size() == 0 && _domain_objs.size() == 0)
173  return;
174 
175  _fe_problem.reinitElemFace(elem, side, _tid);
176 
177  // Reinitialize lower-dimensional variables for use in boundary Materials
178  if (lower_d_elem)
179  _fe_problem.reinitLowerDElem(lower_d_elem, _tid);
180 
181  // Set up Sentinel class so that, even if reinitMaterialsFace() throws, we
182  // still remember to swap back during stack unwinding.
186 
187  for (const auto & uo : userobjs)
188  uo->execute();
189 
190  for (auto & uo : _domain_objs)
191  {
192  uo->preExecuteOnBoundary();
193  uo->executeOnBoundary();
194  }
195 
196  // UserObject Jacobians
197  std::vector<ShapeSideUserObject *> shapers;
199  if (_fe_problem.currentlyComputingJacobian() && shapers.size() > 0)
200  {
201  // Prepare shape functions for ShapeSideUserObjects
202  const auto & jacobian_moose_vars = _fe_problem.getUserObjectJacobianVariables(_tid);
203  for (const auto & jvar : jacobian_moose_vars)
204  {
205  unsigned int jvar_id = jvar->number();
206  auto && dof_indices = jvar->dofIndices();
207 
209 
210  for (const auto & uo : shapers)
211  uo->executeJacobianWrapper(jvar_id, dof_indices);
212  }
213  }
214 }
void reinitMaterialsBoundary(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on a boundary
void queryBoundary(Interfaces iface, BoundaryID bnd, std::vector< T > &results)
void reinitMaterialsFace(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on element faces
virtual void swapBackMaterialsFace(const THREAD_ID tid)
virtual void prepareFaceShapes(unsigned int var, const THREAD_ID tid) override
const std::vector< const MooseVariableFEBase * > & getUserObjectJacobianVariables(const THREAD_ID tid) const
virtual void reinitLowerDElem(const Elem *lower_d_elem, const THREAD_ID tid, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr) override
void reinitElemFace(const Elem *elem, unsigned int side, BoundaryID, const THREAD_ID tid)
SubdomainID _subdomain
The subdomain for the current element.
std::vector< DomainUserObject * > _domain_objs
const bool & currentlyComputingJacobian() const
Returns true if the problem is in the process of computing the Jacobian.
Definition: SubProblem.h:684
The "SwapBackSentinel" class&#39;s destructor guarantees that FEProblemBase::swapBackMaterials{Face,Neighbor}() is called even when an exception is thrown from FEProblemBase::reinitMaterials{Face,Neighbor}.

◆ onElement()

void ComputeUserObjectsThread::onElement ( const Elem *  elem)
overridevirtual

Assembly of the element (not including surface assembly)

Parameters
elem- active element

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 118 of file ComputeUserObjectsThread.C.

119 {
120  _fe_problem.prepare(elem, _tid);
121  _fe_problem.reinitElem(elem, _tid);
122 
123  // Set up Sentinel class so that, even if reinitMaterials() throws, we
124  // still remember to swap back during stack unwinding.
127 
128  for (const auto & uo : _element_objs)
129  {
130  uo->execute();
131 
132  // update the aux solution vector if writable coupled variables are used
133  if (uo->hasWritableCoupledVariables())
134  {
135  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
136  for (auto * var : uo->getWritableCoupledVariables())
137  var->insert(_aux_sys.solution());
138  }
139  }
140 
141  for (auto & uo : _domain_objs)
142  {
143  uo->preExecuteOnElement();
144  uo->executeOnElement();
145  }
146 
147  // UserObject Jacobians
149  {
150  // Prepare shape functions for ShapeElementUserObjects
151  const auto & jacobian_moose_vars = _fe_problem.getUserObjectJacobianVariables(_tid);
152  for (const auto & jvar : jacobian_moose_vars)
153  {
154  unsigned int jvar_id = jvar->number();
155  auto && dof_indices = jvar->dofIndices();
156 
157  _fe_problem.prepareShapes(jvar_id, _tid);
158  for (const auto uo : _shape_element_objs)
159  uo->executeJacobianWrapper(jvar_id, dof_indices);
160  }
161  }
162 }
std::vector< ElementUserObject * > _element_objs
std::vector< ShapeElementUserObject * > _shape_element_objs
virtual void prepare(const Elem *elem, const THREAD_ID tid) override
NumericVector< Number > & solution()
Definition: SystemBase.h:195
const std::vector< const MooseVariableFEBase * > & getUserObjectJacobianVariables(const THREAD_ID tid) const
virtual void reinitElem(const Elem *elem, const THREAD_ID tid) override
virtual void swapBackMaterials(const THREAD_ID tid)
void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)
SubdomainID _subdomain
The subdomain for the current element.
std::vector< DomainUserObject * > _domain_objs
const bool & currentlyComputingJacobian() const
Returns true if the problem is in the process of computing the Jacobian.
Definition: SubProblem.h:684
virtual void prepareShapes(unsigned int var, const THREAD_ID tid) override
The "SwapBackSentinel" class&#39;s destructor guarantees that FEProblemBase::swapBackMaterials{Face,Neighbor}() is called even when an exception is thrown from FEProblemBase::reinitMaterials{Face,Neighbor}.

◆ onExternalSide()

void ComputeUserObjectsThread::onExternalSide ( const Elem *  elem,
unsigned int  side 
)
overridevirtual

Called when iterating over external sides (no side neighbor)

Parameters
elem- Element we are on
side- local side number of the element 'elem'

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 255 of file ComputeUserObjectsThread.C.

256 {
257  // We are not initializing any materials here because objects that perform calculations should
258  // run onBoundary. onExternalSide should be used for mesh updates (e.g. adding/removing
259  // boundaries). Note that _current_elem / _current_side are not getting updated either.
260  for (auto & uo : _domain_objs)
261  uo->executeOnExternalSide(elem, side);
262 }
std::vector< DomainUserObject * > _domain_objs

◆ onInterface()

void ComputeUserObjectsThread::onInterface ( const Elem *  elem,
unsigned int  side,
BoundaryID  bnd_id 
)
overridevirtual

Called when doing interface assembling.

Parameters
elem- Element we are on
side- local side number of the element 'elem'
bnd_id- ID of the interface we are at

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 265 of file ComputeUserObjectsThread.C.

266 {
267  // Pointer to the neighbor we are currently working on.
268  const Elem * neighbor = elem->neighbor_ptr(side);
269  if (!(neighbor->active()))
270  return;
271 
272  std::vector<UserObject *> interface_objs;
273  queryBoundary(Interfaces::InterfaceUserObject, bnd_id, interface_objs);
274 
275  bool has_domain_objs = false;
276  // we need to check all domain user objects because a domain user object may not be active
277  // on the current subdomain but should be executed on the interface that it attaches to
278  for (const auto * const domain_uo : _all_domain_objs)
279  if (domain_uo->shouldExecuteOnInterface())
280  {
281  has_domain_objs = true;
282  break;
283  }
284 
285  // if we do not have any interface user objects and domain user objects on the current
286  // interface
287  if (interface_objs.empty() && !has_domain_objs)
288  return;
289 
291  _fe_problem.reinitNeighbor(elem, side, _tid);
292 
293  // Set up Sentinels so that, even if one of the reinitMaterialsXXX() calls throws, we
294  // still remember to swap back during stack unwinding.
295 
297  _fe_problem.reinitMaterialsFace(elem->subdomain_id(), _tid);
299 
301  _fe_problem.reinitMaterialsNeighbor(neighbor->subdomain_id(), _tid);
302 
303  // Has to happen after face and neighbor properties have been computed. Note that we don't use
304  // a sentinel here because FEProblem::swapBackMaterialsFace is going to handle face materials,
305  // boundary materials, and interface materials (e.g. it queries the boundary material data
306  // with the current element and side
308 
309  for (const auto & uo : interface_objs)
310  uo->execute();
311 
312  for (auto & uo : _all_domain_objs)
313  if (uo->shouldExecuteOnInterface())
314  {
315  uo->preExecuteOnInterface();
316  uo->executeOnInterface();
317  }
318 }
virtual void prepareFace(const Elem *elem, const THREAD_ID tid) override
void reinitMaterialsBoundary(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on a boundary
void queryBoundary(Interfaces iface, BoundaryID bnd, std::vector< T > &results)
void reinitMaterialsFace(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on element faces
virtual void swapBackMaterialsFace(const THREAD_ID tid)
void reinitMaterialsNeighbor(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on the neighboring element face
virtual void swapBackMaterialsNeighbor(const THREAD_ID tid)
virtual void reinitNeighbor(const Elem *elem, unsigned int side, const THREAD_ID tid) override
void reinitMaterialsInterface(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)
std::vector< DomainUserObject * > _all_domain_objs
The "SwapBackSentinel" class&#39;s destructor guarantees that FEProblemBase::swapBackMaterials{Face,Neighbor}() is called even when an exception is thrown from FEProblemBase::reinitMaterials{Face,Neighbor}.

◆ onInternalSide()

void ComputeUserObjectsThread::onInternalSide ( const Elem *  elem,
unsigned int  side 
)
overridevirtual

Called when doing internal edge assembling.

Parameters
elem- Element we are on
side- local side number of the element 'elem'

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 217 of file ComputeUserObjectsThread.C.

218 {
219  // Pointer to the neighbor we are currently working on.
220  const Elem * neighbor = elem->neighbor_ptr(side);
221 
222  // Get the global id of the element and the neighbor
223  const dof_id_type elem_id = elem->id(), neighbor_id = neighbor->id();
224 
225  if (_internal_side_objs.size() == 0 && _domain_objs.size() == 0)
226  return;
227  if (!((neighbor->active() && (neighbor->level() == elem->level()) && (elem_id < neighbor_id)) ||
228  (neighbor->level() < elem->level())))
229  return;
230 
232  _fe_problem.reinitNeighbor(elem, side, _tid);
233 
234  // Set up Sentinels so that, even if one of the reinitMaterialsXXX() calls throws, we
235  // still remember to swap back during stack unwinding.
237  _fe_problem.reinitMaterialsFace(elem->subdomain_id(), _tid);
238 
240  _fe_problem.reinitMaterialsNeighbor(neighbor->subdomain_id(), _tid);
241 
242  for (const auto & uo : _internal_side_objs)
243  if (!uo->blockRestricted() || uo->hasBlocks(neighbor->subdomain_id()))
244  uo->execute();
245 
246  for (auto & uo : _domain_objs)
247  if (!uo->blockRestricted() || uo->hasBlocks(neighbor->subdomain_id()))
248  {
249  uo->preExecuteOnInternalSide();
250  uo->executeOnInternalSide();
251  }
252 }
virtual void prepareFace(const Elem *elem, const THREAD_ID tid) override
void reinitMaterialsFace(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on element faces
virtual void swapBackMaterialsFace(const THREAD_ID tid)
void reinitMaterialsNeighbor(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on the neighboring element face
virtual void swapBackMaterialsNeighbor(const THREAD_ID tid)
std::vector< InternalSideUserObject * > _internal_side_objs
std::vector< DomainUserObject * > _domain_objs
virtual void reinitNeighbor(const Elem *elem, unsigned int side, const THREAD_ID tid) override
uint8_t dof_id_type
The "SwapBackSentinel" class&#39;s destructor guarantees that FEProblemBase::swapBackMaterials{Face,Neighbor}() is called even when an exception is thrown from FEProblemBase::reinitMaterials{Face,Neighbor}.

◆ operator()()

void ThreadedElementLoopBase< ConstElemRange >::operator() ( const ConstElemRange range,
bool  bypass_threading = false 
)
virtualinherited

Reimplemented in NonlinearThread, and ComputeJacobianForScalingThread.

Definition at line 223 of file ThreadedElementLoopBase.h.

224 {
225  try
226  {
227  try
228  {
229  ParallelUniqueId puid;
230  _tid = bypass_threading ? 0 : puid.id;
231 
232  pre();
234 
237  typename RangeType::const_iterator el = range.begin();
238  for (el = range.begin(); el != range.end(); ++el)
239  {
240  if (!keepGoing())
241  break;
242 
243  const Elem * elem = *el;
244 
245  preElement(elem);
246 
248  _subdomain = elem->subdomain_id();
249  if (_subdomain != _old_subdomain)
250  {
253  }
254 
255  onElement(elem);
256 
257  if (_mesh.interiorLowerDBlocks().count(elem->subdomain_id()) > 0 ||
258  _mesh.boundaryLowerDBlocks().count(elem->subdomain_id()) > 0)
259  {
260  postElement(elem);
261  continue;
262  }
263 
264  for (unsigned int side = 0; side < elem->n_sides(); side++)
265  {
266  std::vector<BoundaryID> boundary_ids = _mesh.getBoundaryIDs(elem, side);
267  const Elem * lower_d_elem = _mesh.getLowerDElem(elem, side);
268 
269  if (boundary_ids.size() > 0)
270  for (std::vector<BoundaryID>::iterator it = boundary_ids.begin();
271  it != boundary_ids.end();
272  ++it)
273  {
274  preBoundary(elem, side, *it, lower_d_elem);
276  onBoundary(elem, side, *it, lower_d_elem);
277  }
278 
279  const Elem * neighbor = elem->neighbor_ptr(side);
280  if (neighbor)
281  {
282  preInternalSide(elem, side);
283 
285  _neighbor_subdomain = neighbor->subdomain_id();
288 
289  if (shouldComputeInternalSide(*elem, *neighbor))
290  onInternalSide(elem, side);
291 
292  if (boundary_ids.size() > 0)
293  for (std::vector<BoundaryID>::iterator it = boundary_ids.begin();
294  it != boundary_ids.end();
295  ++it)
296  onInterface(elem, side, *it);
297 
298  postInternalSide(elem, side);
299  }
300  else
301  onExternalSide(elem, side);
302  } // sides
303 
304  postElement(elem);
305  } // range
306 
307  post();
309  }
310  catch (libMesh::LogicError & e)
311  {
312  mooseException("We caught a libMesh error in ThreadedElementLoopBase:", e.what());
313  }
314  catch (MetaPhysicL::LogicError & e)
315  {
317  }
318  }
319  catch (MooseException & e)
320  {
322  }
323 }
virtual void onExternalSide(const Elem *elem, unsigned int side)
Called when iterating over external sides (no side neighbor)
virtual bool keepGoing()
Whether or not the loop should continue.
void resetExecPrintedSets() const
Resets the set of blocks and boundaries visited.
virtual bool shouldComputeInternalSide(const Elem &elem, const Elem &neighbor) const
Whether to compute the internal side for the provided element-neighbor pair.
virtual void onElement(const Elem *elem)
Assembly of the element (not including surface assembly)
const std::set< SubdomainID > & interiorLowerDBlocks() const
Definition: MooseMesh.h:1403
void translateMetaPhysicLError(const MetaPhysicL::LogicError &)
emit a relatively clear error message when we catch a MetaPhysicL logic error
Definition: MooseError.C:112
virtual void printBoundaryExecutionInformation(const unsigned int) const
Print information about the particular ordering of objects on each boundary.
virtual void pre()
Called before the element range loop.
const Elem * getLowerDElem(const Elem *, unsigned short int) const
Returns a const pointer to a lower dimensional element that corresponds to a side of a higher dimensi...
Definition: MooseMesh.C:1698
virtual void subdomainChanged()
Called every time the current subdomain changes (i.e.
virtual void neighborSubdomainChanged()
Called every time the neighbor subdomain changes (i.e.
virtual void preInternalSide(const Elem *elem, unsigned int side)
Called before evaluations on an element internal side.
virtual void postInternalSide(const Elem *elem, unsigned int side)
Called after evaluations on an element internal side.
const SubdomainID INVALID_BLOCK_ID
Definition: MooseTypes.C:20
virtual void onBoundary(const Elem *elem, unsigned int side, BoundaryID bnd_id, const Elem *lower_d_elem=nullptr)
Called when doing boundary assembling.
virtual void postElement(const Elem *elem)
Called after the element assembly is done (including surface assembling)
virtual void printGeneralExecutionInformation() const
Print information about the loop ordering.
virtual void onInterface(const Elem *elem, unsigned int side, BoundaryID bnd_id)
Called when doing interface assembling.
SubdomainID _old_neighbor_subdomain
The subdomain for the last neighbor.
const std::set< SubdomainID > & boundaryLowerDBlocks() const
Definition: MooseMesh.h:1407
virtual void onInternalSide(const Elem *elem, unsigned int side)
Called when doing internal edge assembling.
const_iterator end() const
Provides a way for users to bail out of the current solve.
virtual void caughtMooseException(MooseException &)
Called if a MooseException is caught anywhere during the computation.
const_iterator begin() const
SubdomainID _subdomain
The subdomain for the current element.
std::vector< BoundaryID > getBoundaryIDs(const Elem *const elem, const unsigned short int side) const
Returns a vector of boundary IDs for the requested element on the requested side. ...
SubdomainID _old_subdomain
The subdomain for the last element.
virtual void post()
Called after the element range loop.
virtual void printBlockExecutionInformation() const
Print information about the particular ordering of objects on each block.
virtual void preElement(const Elem *elem)
Called before the element assembly.
virtual void preBoundary(const Elem *elem, unsigned int side, BoundaryID bnd_id, const Elem *lower_d_elem=nullptr)
Called before the boundary assembly.
SubdomainID _neighbor_subdomain
The subdomain for the current neighbor.

◆ post()

void ComputeUserObjectsThread::post ( )
overridevirtual

Called after the element range loop.

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 321 of file ComputeUserObjectsThread.C.

322 {
325 }
void clearActiveMaterialProperties(const THREAD_ID tid)
Clear the active material properties.
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid) override
Clear the active elemental MooseVariableFEBase.

◆ postElement()

void ThreadedElementLoopBase< ConstElemRange >::postElement ( const Elem *  elem)
virtualinherited

Called after the element assembly is done (including surface assembling)

Parameters
elem- active element

Reimplemented in ComputeJacobianBlocksThread, NonlinearThread, ComputeIndicatorThread, ComputeJacobianThread, and ComputeMarkerThread.

Definition at line 351 of file ThreadedElementLoopBase.h.

352 {
353 }

◆ postInternalSide()

void ThreadedElementLoopBase< ConstElemRange >::postInternalSide ( const Elem *  elem,
unsigned int  side 
)
virtualinherited

Called after evaluations on an element internal side.

Parameters
elem- Element we are on
side- local side number of the element 'elem'

Reimplemented in ComputeJacobianBlocksThread.

Definition at line 381 of file ThreadedElementLoopBase.h.

382 {
383 }

◆ pre()

void ThreadedElementLoopBase< ConstElemRange >::pre ( )
virtualinherited

Called before the element range loop.

Definition at line 327 of file ThreadedElementLoopBase.h.

Referenced by ComputeJacobianForScalingThread::operator()().

328 {
329 }

◆ preBoundary()

void ThreadedElementLoop< ConstElemRange >::preBoundary ( const Elem *  elem,
unsigned int  side,
BoundaryID  bnd_id,
const Elem *  lower_d_elem = nullptr 
)
overridevirtualinherited

Called before the boundary assembly.

Parameters
elem- The element we are checking is on the boundary.
side- The side of the element in question.
bnd_id- ID of the boundary we are at
lower_d_elem- Lower dimensional element (e.g. Mortar)

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 129 of file ThreadedElementLoop.h.

133 {
135 }
virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid) override
sets the current boundary ID in assembly
Base class for assembly-like calculations.

◆ preElement()

void ThreadedElementLoop< ConstElemRange >::preElement ( const Elem *  elem)
overridevirtualinherited

Called before the element assembly.

Parameters
elem- active element

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 115 of file ThreadedElementLoop.h.

Referenced by ComputeJacobianForScalingThread::operator()().

116 {
118 }
virtual void setCurrentSubdomainID(const Elem *elem, const THREAD_ID tid) override
Base class for assembly-like calculations.

◆ preInternalSide()

void ThreadedElementLoop< ConstElemRange >::preInternalSide ( const Elem *  elem,
unsigned int  side 
)
overridevirtualinherited

Called before evaluations on an element internal side.

Parameters
elem- Element we are on
side- local side number of the element 'elem'

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 122 of file ThreadedElementLoop.h.

123 {
125 }
Base class for assembly-like calculations.
virtual void setNeighborSubdomainID(const Elem *elem, unsigned int side, const THREAD_ID tid) override

◆ prepareElement()

void ThreadedElementLoop< ConstElemRange >::prepareElement ( const Elem *  elem)
protectedinherited

Definition at line 186 of file ThreadedElementLoop.h.

Referenced by NonlinearThread::onElement().

187 {
188  _fe_problem.prepare(elem, this->_tid);
189  _fe_problem.reinitElem(elem, this->_tid);
191 }
virtual void prepare(const Elem *elem, const THREAD_ID tid) override
virtual void reinitElem(const Elem *elem, const THREAD_ID tid) override
void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)
SubdomainID _subdomain
The subdomain for the current element.

◆ printBlockExecutionInformation()

void ComputeUserObjectsThread::printBlockExecutionInformation ( ) const
overrideprotectedvirtual

Print information about the loop, mostly order of execution of particular objects.

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 363 of file ComputeUserObjectsThread.C.

364 {
366  return;
367 
368  // Gather all user objects that may execute
369  // TODO: restrict this gathering of boundary objects to boundaries that are present
370  // in the current block
371  std::vector<ShapeSideUserObject *> shapers;
372  const_cast<ComputeUserObjectsThread *>(this)->queryBoundary(
374 
375  std::vector<SideUserObject *> side_uos;
376  const_cast<ComputeUserObjectsThread *>(this)->queryBoundary(
378 
379  std::vector<InterfaceUserObject *> interface_objs;
380  const_cast<ComputeUserObjectsThread *>(this)->queryBoundary(
382 
383  std::vector<const DomainUserObject *> domain_interface_uos;
384  for (const auto * const domain_uo : _domain_objs)
385  if (domain_uo->shouldExecuteOnInterface())
386  domain_interface_uos.push_back(domain_uo);
387 
388  // Approximation of the number of user objects currently executing
389  const auto num_objects = _element_objs.size() + _domain_objs.size() + _shape_element_objs.size() +
390  side_uos.size() + shapers.size() + _internal_side_objs.size() +
391  interface_objs.size() + domain_interface_uos.size();
392 
393  const auto & console = _fe_problem.console();
394  const auto & execute_on = _fe_problem.getCurrentExecuteOnFlag();
395 
396  if (num_objects > 0)
397  {
398  if (_blocks_exec_printed.count(_subdomain))
399  return;
400 
401  console << "[DBG] Ordering of User Objects on block " << _subdomain << std::endl;
402  // Output specific ordering of objects
403  printExecutionOrdering<ElementUserObject>(_element_objs, "element user objects");
404  printExecutionOrdering<DomainUserObject>(_domain_objs, "domain user objects");
406  printExecutionOrdering<ShapeElementUserObject>(
407  _shape_element_objs, "element user objects contributing to the Jacobian");
408  printExecutionOrdering<SideUserObject>(side_uos, "side user objects");
410  printExecutionOrdering<ShapeSideUserObject>(shapers,
411  "side user objects contributing to the Jacobian");
412  printExecutionOrdering<InternalSideUserObject>(_internal_side_objs,
413  "internal side user objects");
414  printExecutionOrdering<InterfaceUserObject>(interface_objs, "interface user objects");
415  console << "[DBG] Only user objects active on local element/sides are executed" << std::endl;
416  }
417  else if (num_objects == 0 && !_blocks_exec_printed.count(_subdomain))
418  console << "[DBG] No User Objects on block " << _subdomain << " on " << execute_on.name()
419  << std::endl;
420 
421  // Mark subdomain as having printed to avoid printing again
423 }
std::vector< ElementUserObject * > _element_objs
std::vector< ShapeElementUserObject * > _shape_element_objs
const ExecFlagType & getCurrentExecuteOnFlag() const
Return/set the current execution flag.
void queryBoundary(Interfaces iface, BoundaryID bnd, std::vector< T > &results)
bool shouldPrintExecution(const THREAD_ID tid) const
Check whether the problem should output execution orders at this time.
std::set< SubdomainID > _blocks_exec_printed
Keep track of which blocks were visited.
const ConsoleStream & console() const
Return console handle.
Definition: Problem.h:48
Class for threaded computation of UserObjects.
std::vector< InternalSideUserObject * > _internal_side_objs
SubdomainID _subdomain
The subdomain for the current element.
std::vector< DomainUserObject * > _domain_objs
const bool & currentlyComputingJacobian() const
Returns true if the problem is in the process of computing the Jacobian.
Definition: SubProblem.h:684
const BoundaryID ANY_BOUNDARY_ID
Definition: MooseTypes.C:21

◆ printBoundaryExecutionInformation()

virtual void ThreadedElementLoopBase< ConstElemRange >::printBoundaryExecutionInformation ( const unsigned int  ) const
inlineprotectedvirtualinherited

Print information about the particular ordering of objects on each boundary.

Reimplemented in NonlinearThread.

Definition at line 184 of file ThreadedElementLoopBase.h.

184 {}

◆ printExecutionOrdering() [1/2]

void ThreadedElementLoop< ConstElemRange >::printExecutionOrdering ( const std::vector< T *> &  objs,
const bool  print_header = true,
const std::string &  line_prefix = "[DBG]" 
) const
protectedinherited

Routine to output the ordering of objects within a vector of pointers to these objects.

These objects must implement the name() routine, and it must return a string or compatible type.

Template Parameters
Tthe object type
Parameters
objsthe vector with all the objects (should be pointers)
objects_typethe name of the type of objects. Defaults to the CPP object name
print_headerwhether to print a header about the timing of execution and the type of objects

Definition at line 148 of file ThreadedElementLoop.h.

151 {
152  if (!objs.size())
153  return;
154 
155  auto & console = _fe_problem.console();
156  const auto objects_type = MooseUtils::prettyCppType(objs[0]);
157  std::vector<MooseObject *> moose_objs;
158  for (auto obj_ptr : objs)
159  moose_objs.push_back(dynamic_cast<MooseObject *>(obj_ptr));
160  const auto names = ConsoleUtils::mooseObjectVectorToString(moose_objs);
161 
162  // Print string with a DBG prefix and with sufficient line breaks
163  std::string message = print_header ? "Executing " + objects_type + " on " +
165  : "";
166  message += (print_header ? "Order of execution:\n" : "") + names;
167  console << ConsoleUtils::formatString(message, line_prefix) << std::endl;
168 }
std::string mooseObjectVectorToString(const std::vector< MooseObject *> &objs, const std::string &sep=" ")
Routine to output the name of MooseObjects in a string.
Definition: ConsoleUtils.C:598
const std::string & name() const
Definition: MooseEnumItem.h:35
const ExecFlagType & getCurrentExecuteOnFlag() const
Return/set the current execution flag.
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:582
const ConsoleStream & console() const
Return console handle.
Definition: Problem.h:48
std::string prettyCppType(const std::string &cpp_type)
Definition: MooseUtils.C:1246

◆ printExecutionOrdering() [2/2]

void ThreadedElementLoop< ConstElemRange >::printExecutionOrdering ( const std::vector< std::shared_ptr< T >> &  objs_ptrs,
const bool  print_header = true,
const std::string &  line_prefix = "[DBG]" 
) const
protectedinherited

Definition at line 173 of file ThreadedElementLoop.h.

177 {
178  std::vector<T *> regular_ptrs;
179  for (auto shared_ptr : objs_ptrs)
180  regular_ptrs.push_back(shared_ptr.get());
181  printExecutionOrdering<T>(regular_ptrs, print_header, line_prefix);
182 }

◆ printGeneralExecutionInformation()

void ComputeUserObjectsThread::printGeneralExecutionInformation ( ) const
overrideprotectedvirtual

Print general information about the loop, like the ordering of class of objects.

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 333 of file ComputeUserObjectsThread.C.

334 {
336  {
337  const auto & console = _fe_problem.console();
338  const auto & execute_on = _fe_problem.getCurrentExecuteOnFlag();
339  console << "[DBG] Computing elemental user objects on " << execute_on << std::endl;
340  mooseDoOnce(console << "[DBG] Execution order of objects types on each element then its sides:"
341  << std::endl;
342  // onElement
343  console << "[DBG] - element user objects" << std::endl;
344  console << "[DBG] - domain user objects" << std::endl;
345  console << "[DBG] - element user objects contributing to the Jacobian" << std::endl;
346 
347  // onBoundary
348  console << "[DBG] - side user objects" << std::endl;
349  console << "[DBG] - domain user objects executing on sides" << std::endl;
350  console << "[DBG] - side user objects contributing to the Jacobian" << std::endl;
351 
352  // onInternalSide
353  console << "[DBG] - internal side user objects" << std::endl;
354  console << "[DBG] - domain user objects executing on internal sides" << std::endl;
355 
356  // onInterface
357  console << "[DBG] - interface user objects" << std::endl;
358  console << "[DBG] - domain user objects executing at interfaces" << std::endl;);
359  }
360 }
const ExecFlagType & getCurrentExecuteOnFlag() const
Return/set the current execution flag.
bool shouldPrintExecution(const THREAD_ID tid) const
Check whether the problem should output execution orders at this time.
const ConsoleStream & console() const
Return console handle.
Definition: Problem.h:48

◆ printVectorOrdering()

template<typename T >
void ComputeUserObjectsThread::printVectorOrdering ( std::vector< T *>  uos,
const std::string &  name 
) const
protected

Format output of vector of UOs.

◆ queryBoundary()

template<typename T >
void ComputeUserObjectsThread::queryBoundary ( Interfaces  iface,
BoundaryID  bnd,
std::vector< T > &  results 
)
inlineprivate

Definition at line 77 of file ComputeUserObjectsThread.h.

Referenced by onBoundary(), onInterface(), and printBlockExecutionInformation().

78  {
79  _query_boundary.queryInto(results, _tid, std::make_tuple(bnd, false), iface);
80  }
TheWarehouse::QueryCache< AttribThread, AttribBoundaries, AttribInterfaces > _query_boundary
std::vector< T * > & queryInto(std::vector< T *> &results, Args &&... args)
queryInto executes the query and stores the results in the given vector.
Definition: TheWarehouse.h:311

◆ querySubdomain()

template<typename T >
void ComputeUserObjectsThread::querySubdomain ( Interfaces  iface,
std::vector< T > &  results 
)
inlineprivate

Definition at line 72 of file ComputeUserObjectsThread.h.

Referenced by subdomainChanged().

73  {
74  _query_subdomain.queryInto(results, _tid, _subdomain, iface);
75  }
TheWarehouse::QueryCache< AttribThread, AttribSubdomains, AttribInterfaces > _query_subdomain
std::vector< T * > & queryInto(std::vector< T *> &results, Args &&... args)
queryInto executes the query and stores the results in the given vector.
Definition: TheWarehouse.h:311
SubdomainID _subdomain
The subdomain for the current element.

◆ resetExecPrintedSets()

void ThreadedElementLoopBase< ConstElemRange >::resetExecPrintedSets ( ) const
protectedinherited

Resets the set of blocks and boundaries visited.

Definition at line 444 of file ThreadedElementLoopBase.h.

445 {
446  _blocks_exec_printed.clear();
447  _boundaries_exec_printed.clear();
448 }
std::set< SubdomainID > _blocks_exec_printed
Keep track of which blocks were visited.
std::set< BoundaryID > _boundaries_exec_printed
Keep track of which boundaries were visited.

◆ shouldComputeInternalSide()

bool ThreadedElementLoopBase< ConstElemRange >::shouldComputeInternalSide ( const Elem &  elem,
const Elem &  neighbor 
) const
protectedvirtualinherited

Whether to compute the internal side for the provided element-neighbor pair.

Typically this will return true if the element id is less than the neighbor id when the elements are equal level, or when the element is more refined than the neighbor, and then false otherwise. One type of loop where the logic will be different is when projecting stateful material properties

Reimplemented in NonlinearThread, and FlagElementsThread.

Definition at line 419 of file ThreadedElementLoopBase.h.

421 {
422  auto level = [this](const auto & elem_arg)
423  {
424  if (_mesh.doingPRefinement())
425  return elem_arg.p_level();
426  else
427  return elem_arg.level();
428  };
429  const auto elem_id = elem.id(), neighbor_id = neighbor.id();
430  const auto elem_level = level(elem), neighbor_level = level(neighbor);
431 
432  // When looping over elements and then sides, we need to make sure that we do not duplicate
433  // effort, e.g. if a face is shared by element 1 and element 2, then we do not want to do compute
434  // work both when we are visiting element 1 *and* then later when visiting element 2. Our rule is
435  // to only compute when we are visiting the element that has the lower element id when element and
436  // neighbor are of the same adaptivity level, and then if they are not of the same level, then
437  // we only compute when we are visiting the finer element
438  return (neighbor.active() && (neighbor_level == elem_level) && (elem_id < neighbor_id)) ||
439  (neighbor_level < elem_level);
440 }
void doingPRefinement(bool doing_p_refinement)
Indicate whether the kind of adaptivity we&#39;re doing is p-refinement.
Definition: MooseMesh.h:1347

◆ subdomainChanged()

void ComputeUserObjectsThread::subdomainChanged ( )
overridevirtual

Called every time the current subdomain changes (i.e.

the subdomain of this element is not the same as the subdomain of the last element). Beware of over-using this! You might think that you can do some expensive stuff in here and get away with it... but there are applications that have TONS of subdomains....

Reimplemented from ThreadedElementLoopBase< ConstElemRange >.

Definition at line 52 of file ComputeUserObjectsThread.C.

53 {
54  // for the current thread get block objects for the current subdomain and *all* side objects
55  std::vector<UserObject *> objs;
58  objs);
59 
60  _query.clone()
62  .condition<AttribInterfaces>(Interfaces::DomainUserObject)
63  .queryInto(_all_domain_objs);
64 
65  std::vector<UserObject *> side_objs;
66  _query.clone()
68  .condition<AttribInterfaces>(Interfaces::SideUserObject)
69  .queryInto(side_objs);
70 
71  objs.insert(objs.begin(), side_objs.begin(), side_objs.end());
72 
73  // collect dependencies and run subdomain setup
75 
76  std::set<MooseVariableFEBase *> needed_moose_vars;
77  std::unordered_set<unsigned int> needed_mat_props;
78  std::set<TagID> needed_fe_var_vector_tags;
79  for (const auto obj : objs)
80  {
81  auto v_obj = dynamic_cast<MooseVariableDependencyInterface *>(obj);
82  if (v_obj)
83  {
84  const auto & v_deps = v_obj->getMooseVariableDependencies();
85  needed_moose_vars.insert(v_deps.begin(), v_deps.end());
86  }
87 
88  auto m_obj = dynamic_cast<MaterialPropertyInterface *>(obj);
89  if (m_obj)
90  {
91  auto & m_deps = m_obj->getMatPropDependencies();
92  needed_mat_props.insert(m_deps.begin(), m_deps.end());
93  }
94 
95  auto c_obj = dynamic_cast<Coupleable *>(obj);
96  if (c_obj)
97  {
98  const auto & tag_deps = c_obj->getFEVariableCoupleableVectorTags();
99  needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
100  }
101 
102  obj->subdomainSetup();
103  }
105  _subdomain, needed_fe_var_vector_tags, _tid);
106 
108  _fe_problem.setActiveFEVariableCoupleableVectorTags(needed_fe_var_vector_tags, _tid);
109  _fe_problem.prepareMaterials(needed_mat_props, _subdomain, _tid);
110 
115 }
virtual const std::unordered_set< unsigned int > & getMatPropDependencies() const
Retrieve the set of material properties that this object depends on.
const std::set< MooseVariableFieldBase * > & getMooseVariableDependencies() const
Retrieve the set of MooseVariableFieldBase that this object depends on.
std::vector< ElementUserObject * > _element_objs
std::vector< ShapeElementUserObject * > _shape_element_objs
void querySubdomain(Interfaces iface, std::vector< T > &results)
const MaterialWarehouse & getMaterialWarehouse() const
virtual void setActiveElementalMooseVariables(const std::set< MooseVariableFEBase *> &moose_vars, const THREAD_ID tid) override
Set the MOOSE variables to be reinited on each element.
const TheWarehouse::Query _query
QueryCache clone() const
clone creates and returns an independent copy of the query in its current state.
Definition: TheWarehouse.h:292
Interface for objects that needs coupling capabilities.
Definition: Coupleable.h:45
void updateBlockFEVariableCoupledVectorTagDependency(SubdomainID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
Update FE variable coupleable vector tag vector.
virtual void subdomainSetup(SubdomainID subdomain, const THREAD_ID tid)
An interface for accessing Materials.
std::vector< InternalSideUserObject * > _internal_side_objs
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284
SubdomainID _subdomain
The subdomain for the current element.
std::vector< DomainUserObject * > _domain_objs
virtual void setActiveFEVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid) override
void prepareMaterials(const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)
Add the MooseVariables and the material properties that the current materials depend on to the depend...
std::set< TagID > & getFEVariableCoupleableVectorTags()
Definition: Coupleable.h:106
std::vector< DomainUserObject * > _all_domain_objs

Member Data Documentation

◆ _all_domain_objs

std::vector<DomainUserObject *> ComputeUserObjectsThread::_all_domain_objs
private

Definition at line 90 of file ComputeUserObjectsThread.h.

Referenced by onInterface(), and subdomainChanged().

◆ _aux_sys

AuxiliarySystem& ComputeUserObjectsThread::_aux_sys
private

Definition at line 92 of file ComputeUserObjectsThread.h.

Referenced by onElement().

◆ _blocks_exec_printed

std::set<SubdomainID> ThreadedElementLoopBase< ConstElemRange >::_blocks_exec_printed
mutableprotectedinherited

◆ _boundaries_exec_printed

std::set<BoundaryID> ThreadedElementLoopBase< ConstElemRange >::_boundaries_exec_printed
mutableprotectedinherited

Keep track of which boundaries were visited.

Definition at line 190 of file ThreadedElementLoopBase.h.

Referenced by NonlinearThread::printBoundaryExecutionInformation().

◆ _domain_objs

std::vector<DomainUserObject *> ComputeUserObjectsThread::_domain_objs
private

◆ _element_objs

std::vector<ElementUserObject *> ComputeUserObjectsThread::_element_objs
private

◆ _fe_problem

FEProblemBase& ThreadedElementLoop< ConstElemRange >::_fe_problem
protectedinherited

Definition at line 62 of file ThreadedElementLoop.h.

Referenced by ComputeResidualThread::accumulate(), ComputeResidualAndJacobianThread::accumulate(), ComputeResidualThread::accumulateLower(), ComputeResidualAndJacobianThread::accumulateLower(), ComputeJacobianThread::accumulateLower(), ComputeResidualThread::accumulateNeighbor(), ComputeResidualAndJacobianThread::accumulateNeighbor(), ComputeJacobianThread::accumulateNeighbor(), ComputeResidualThread::accumulateNeighborLower(), ComputeResidualAndJacobianThread::accumulateNeighborLower(), ComputeJacobianThread::accumulateNeighborLower(), ComputeJacobianThread::compute(), ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), NonlinearThread::computeOnElement(), ComputeFullJacobianThread::computeOnInterface(), ComputeFullJacobianThread::computeOnInternalFace(), ComputeResidualThread::determineObjectWarehouses(), ComputeJacobianThread::determineObjectWarehouses(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), NonlinearThread::onBoundary(), onBoundary(), ComputeElemDampingThread::onElement(), NonlinearThread::onElement(), onElement(), NonlinearThread::onInterface(), onInterface(), NonlinearThread::onInternalSide(), onInternalSide(), post(), ComputeJacobianThread::postElement(), ComputeJacobianBlocksThread::postElement(), ComputeJacobianBlocksThread::postInternalSide(), NonlinearThread::prepareFace(), printBlockExecutionInformation(), NonlinearThread::printBlockExecutionInformation(), NonlinearThread::printBoundaryExecutionInformation(), ComputeElemDampingThread::printGeneralExecutionInformation(), printGeneralExecutionInformation(), NonlinearThread::printGeneralExecutionInformation(), NonlinearThread::subdomainChanged(), and subdomainChanged().

◆ _interface_user_objects

std::vector<InterfaceUserObject *> ComputeUserObjectsThread::_interface_user_objects
private

Definition at line 86 of file ComputeUserObjectsThread.h.

◆ _internal_side_objs

std::vector<InternalSideUserObject *> ComputeUserObjectsThread::_internal_side_objs
private

◆ _mesh

MooseMesh& ThreadedElementLoopBase< ConstElemRange >::_mesh
protectedinherited

◆ _neighbor_subdomain

SubdomainID ThreadedElementLoopBase< ConstElemRange >::_neighbor_subdomain
protectedinherited

◆ _old_neighbor_subdomain

SubdomainID ThreadedElementLoopBase< ConstElemRange >::_old_neighbor_subdomain
protectedinherited

The subdomain for the last neighbor.

Definition at line 175 of file ThreadedElementLoopBase.h.

◆ _old_subdomain

SubdomainID ThreadedElementLoopBase< ConstElemRange >::_old_subdomain
protectedinherited

The subdomain for the last element.

Definition at line 169 of file ThreadedElementLoopBase.h.

Referenced by ComputeJacobianForScalingThread::operator()().

◆ _query

const TheWarehouse::Query ComputeUserObjectsThread::_query
private

Definition at line 82 of file ComputeUserObjectsThread.h.

Referenced by subdomainChanged().

◆ _query_boundary

TheWarehouse::QueryCache<AttribThread, AttribBoundaries, AttribInterfaces> ComputeUserObjectsThread::_query_boundary
private

Definition at line 84 of file ComputeUserObjectsThread.h.

Referenced by queryBoundary().

◆ _query_subdomain

TheWarehouse::QueryCache<AttribThread, AttribSubdomains, AttribInterfaces> ComputeUserObjectsThread::_query_subdomain
private

Definition at line 83 of file ComputeUserObjectsThread.h.

Referenced by querySubdomain().

◆ _shape_element_objs

std::vector<ShapeElementUserObject *> ComputeUserObjectsThread::_shape_element_objs
private

◆ _subdomain

SubdomainID ThreadedElementLoopBase< ConstElemRange >::_subdomain
protectedinherited

◆ _tid

THREAD_ID ThreadedElementLoopBase< ConstElemRange >::_tid
protectedinherited

Definition at line 163 of file ThreadedElementLoopBase.h.

Referenced by ComputeResidualThread::accumulate(), ComputeResidualAndJacobianThread::accumulate(), ComputeResidualThread::accumulateLower(), ComputeResidualAndJacobianThread::accumulateLower(), ComputeJacobianThread::accumulateLower(), ComputeResidualThread::accumulateNeighbor(), ComputeResidualAndJacobianThread::accumulateNeighbor(), ComputeJacobianThread::accumulateNeighbor(), ComputeResidualThread::accumulateNeighborLower(), ComputeResidualAndJacobianThread::accumulateNeighborLower(), ComputeJacobianThread::accumulateNeighborLower(), ComputeFullJacobianThread::computeOnBoundary(), NonlinearThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), NonlinearThread::computeOnElement(), ComputeFullJacobianThread::computeOnInterface(), NonlinearThread::computeOnInterface(), ComputeResidualThread::computeOnInternalFace(), ComputeFullJacobianThread::computeOnInternalFace(), ComputeResidualAndJacobianThread::computeOnInternalFace(), ComputeJacobianThread::computeOnInternalFace(), NonlinearThread::computeOnInternalFace(), ComputeResidualThread::determineObjectWarehouses(), ComputeJacobianThread::determineObjectWarehouses(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), ComputeMaterialsObjectThread::onBoundary(), NonlinearThread::onBoundary(), onBoundary(), ComputeMarkerThread::onElement(), ComputeElemDampingThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeIndicatorThread::onElement(), NonlinearThread::onElement(), onElement(), ComputeMaterialsObjectThread::onInterface(), NonlinearThread::onInterface(), onInterface(), ComputeMaterialsObjectThread::onInternalSide(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), onInternalSide(), ComputeJacobianForScalingThread::operator()(), ComputeMaterialsObjectThread::post(), ComputeMarkerThread::post(), ComputeIndicatorThread::post(), post(), ComputeJacobianThread::postElement(), ComputeJacobianBlocksThread::postElement(), ComputeJacobianBlocksThread::postInternalSide(), NonlinearThread::prepareFace(), ComputeMarkerThread::printBlockExecutionInformation(), ComputeIndicatorThread::printBlockExecutionInformation(), printBlockExecutionInformation(), NonlinearThread::printBlockExecutionInformation(), NonlinearThread::printBoundaryExecutionInformation(), ComputeElemDampingThread::printGeneralExecutionInformation(), ComputeMarkerThread::printGeneralExecutionInformation(), ComputeIndicatorThread::printGeneralExecutionInformation(), printGeneralExecutionInformation(), NonlinearThread::printGeneralExecutionInformation(), queryBoundary(), querySubdomain(), NonlinearThread::shouldComputeInternalSide(), ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and subdomainChanged().


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