ComputeNodalUserObjectsThread Class Reference

#include <ComputeNodalUserObjectsThread.h>

Inheritance diagram for ComputeNodalUserObjectsThread:

Public Member Functions
	ComputeNodalUserObjectsThread (FEProblemBase &fe_problem, const TheWarehouse::Query &query)
	ComputeNodalUserObjectsThread (ComputeNodalUserObjectsThread &x, Threads::split split)
virtual	~ComputeNodalUserObjectsThread ()
void	subdomainChanged ()
virtual void	onNode (ConstNodeRange::const_iterator &node_it) override
void	join (const ComputeNodalUserObjectsThread &)
void	printGeneralExecutionInformation () const override
	Print information about the loop, mostly order of execution of objects.
void	operator() (const ConstNodeRange &range)
virtual void	pre ()
	Called before the node range loop.
virtual void	post ()
	Called after the node range loop.
virtual void	onNode (ConstNodeRange::const_iterator &node_it)
	Called for each node.
virtual void	postNode (ConstNodeRange::const_iterator &node_it)
	Called after the node assembly is done (including surface assembling)
virtual void	caughtMooseException (MooseException &e)
	Called if a MooseException is caught anywhere during the computation.
virtual bool	keepGoing ()
	Whether or not the loop should continue.

Protected Attributes
FEProblemBase &	_fe_problem
THREAD_ID	_tid

Private Attributes
const TheWarehouse::Query	_query
AuxiliarySystem &	_aux_sys
std::set< SubdomainID >	_block_ids

Static Private Attributes
static Threads::spin_mutex	writable_variable_mutex

Detailed Description

Definition at line 19 of file ComputeNodalUserObjectsThread.h.

Constructor & Destructor Documentation

ComputeNodalUserObjectsThread() [1/2]

ComputeNodalUserObjectsThread::ComputeNodalUserObjectsThread	(	FEProblemBase &	fe_problem,
		const TheWarehouse::Query &	query
	)

Definition at line 22 of file ComputeNodalUserObjectsThread.C.

  : ThreadedNodeLoop<ConstNodeRange, ConstNodeRange::const_iterator>(fe_problem),
    _query(query),
    _aux_sys(fe_problem.getAuxiliarySystem())
{
}

ComputeNodalUserObjectsThread() [2/2]

ComputeNodalUserObjectsThread::ComputeNodalUserObjectsThread	(	ComputeNodalUserObjectsThread &	x,
		Threads::split	split
	)

Definition at line 31 of file ComputeNodalUserObjectsThread.C.

  : ThreadedNodeLoop<ConstNodeRange, ConstNodeRange::const_iterator>(x, split),
    _query(x._query),
    _aux_sys(x._aux_sys)
{
}

~ComputeNodalUserObjectsThread()

ComputeNodalUserObjectsThread::~ComputeNodalUserObjectsThread ( )

virtual

Definition at line 39 of file ComputeNodalUserObjectsThread.C.

{}

Member Function Documentation

caughtMooseException()

virtual void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::caughtMooseException ( MooseException &  e )

inlinevirtualinherited

Called if a MooseException is caught anywhere during the computation.

The single input parameter taken is a MooseException object.

Definition at line 56 of file ThreadedNodeLoop.h.

  {
    Threads::spin_mutex::scoped_lock lock(threaded_node_mutex);
 
    std::string what(e.what());
    _fe_problem.setException(what);
  };

join()

void ComputeNodalUserObjectsThread::join

(

const ComputeNodalUserObjectsThread &

)

Definition at line 129 of file ComputeNodalUserObjectsThread.C.

{
}

keepGoing()

virtual bool ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::keepGoing ( )

inlinevirtualinherited

Whether or not the loop should continue.

Returns

true to keep going, false to stop.

Definition at line 69 of file ThreadedNodeLoop.h.

{ return !_fe_problem.hasException(); }

onNode() [1/2]

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::onNode ( ConstNodeRange::const_iterator &  node_it )

virtualinherited

Called for each node.

Definition at line 43 of file ThreadedNodeLoop.h.

{
}

onNode() [2/2]

void ComputeNodalUserObjectsThread::onNode ( ConstNodeRange::const_iterator &  node_it )

overridevirtual

Definition at line 60 of file ComputeNodalUserObjectsThread.C.

{
  const Node * node = *node_it;
 
  const auto & block_ids = _aux_sys.mesh().getNodeBlockIds(*node);
  if (_block_ids != block_ids)
  {
    _block_ids.clear();
    _block_ids.insert(block_ids.begin(), block_ids.end());
    subdomainChanged();
  }
 
  _fe_problem.reinitNode(node, _tid);
 
  std::vector<NodalUserObject *> objs;
 
  // Boundary Restricted
  std::vector<BoundaryID> nodeset_ids;
  _fe_problem.mesh().getMesh().get_boundary_info().boundary_ids(node, nodeset_ids);
  for (const auto & bnd : nodeset_ids)
  {
    _query.clone()
        .condition<AttribThread>(_tid)
        .condition<AttribInterfaces>(Interfaces::NodalUserObject)
        .condition<AttribBoundaries>(bnd, true)
        .queryInto(objs);
    for (const auto & uo : objs)
    {
      uo->execute();
 
      // update the aux solution vector if writable coupled variables are used
      if (uo->hasWritableCoupledVariables())
        for (auto * var : uo->getWritableCoupledVariables())
          var->insert(_aux_sys.solution());
    }
  }
 
  // Block Restricted
  // NodalUserObjects may be block restricted, in this case by default the execute() method is
  // called for each subdomain that the node "belongs". This may be disabled in the NodalUserObject
  // by setting "unique_node_execute = true".
 
  // To enforce the unique execution this vector is populated and checked if the unique flag is
  // enabled.
  std::set<NodalUserObject *> computed;
  for (const auto & block : block_ids)
  {
    _query.clone()
        .condition<AttribThread>(_tid)
        .condition<AttribInterfaces>(Interfaces::NodalUserObject)
        .condition<AttribSubdomains>(block)
        .queryInto(objs);
 
    for (const auto & uo : objs)
      if (!uo->isUniqueNodeExecute() || computed.count(uo) == 0)
      {
        uo->execute();
 
        // update the aux solution vector if writable coupled variables are used
        if (uo->hasWritableCoupledVariables())
          for (auto * var : uo->getWritableCoupledVariables())
            var->insert(_aux_sys.solution());
 
        computed.insert(uo);
      }
  }
}

operator()()

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::operator() ( const ConstNodeRange &  range )

inherited

Definition at line 28 of file ThreadedNodeLoop.h.

{
  try
  {
    ParallelUniqueId puid;
    _tid = puid.id;
 
    pre();
    printGeneralExecutionInformation();
 
    for (IteratorType nd = range.begin(); nd != range.end(); ++nd)
    {
      if (!keepGoing())
        break;
 
      onNode(nd);
 
      postNode(nd);
    }
 
    post();
  }
  catch (MooseException & e)
  {
    caughtMooseException(e);
  }
}

post()

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::post ( )

virtualinherited

Called after the node range loop.

Reimplemented in ComputeNodalAuxVarsThread< AuxKernelType >.

Definition at line 38 of file ThreadedNodeLoop.h.

{
}

postNode()

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::postNode ( ConstNodeRange::const_iterator &  node_it )

virtualinherited

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

Parameters

node	- active node

Definition at line 50 of file ThreadedNodeLoop.h.

{
}

pre()

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::pre ( )

virtualinherited

Called before the node range loop.

Reimplemented in ComputeNodalKernelJacobiansThread, and ComputeNodalKernelsThread.

Definition at line 33 of file ThreadedNodeLoop.h.

{
}

printGeneralExecutionInformation()

void ComputeNodalUserObjectsThread::printGeneralExecutionInformation ( ) const

overridevirtual

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

Reimplemented from ThreadedNodeLoop< ConstNodeRange, ConstNodeRange::const_iterator >.

Definition at line 134 of file ComputeNodalUserObjectsThread.C.

{
  if (!_fe_problem.shouldPrintExecution(_tid))
    return;
 
  // Get all nodal UOs
  std::vector<MooseObject *> nodal_uos;
  _query.clone()
      .condition<AttribThread>(_tid)
      .condition<AttribInterfaces>(Interfaces::NodalUserObject)
      .queryInto(nodal_uos);
 
  if (nodal_uos.size())
  {
    const auto & console = _fe_problem.console();
    const auto & execute_on = _fe_problem.getCurrentExecuteOnFlag();
    console << "[DBG] Computing nodal user objects on " << execute_on << std::endl;
    mooseDoOnce(
        console << "[DBG] Ordering on nodes:" << std::endl;
        console << "[DBG] - boundary restricted user objects" << std::endl;
        console << "[DBG] - block restricted user objects" << std::endl;
        console << "[DBG] Nodal UOs executed on each node will differ based on these restrictions"
                << std::endl;);
 
    auto message = ConsoleUtils::mooseObjectVectorToString(nodal_uos);
    message = "Order of execution:\n" + message;
    console << ConsoleUtils::formatString(message, "[DBG]") << std::endl;
  }
}

subdomainChanged()

void ComputeNodalUserObjectsThread::subdomainChanged

(

)

Definition at line 42 of file ComputeNodalUserObjectsThread.C.

{
  std::vector<NodalUserObject *> objs;
  _query.clone()
      .condition<AttribThread>(_tid)
      .condition<AttribInterfaces>(Interfaces::NodalUserObject)
      .queryInto(objs);
 
  std::set<TagID> needed_vector_tags;
  for (const auto obj : objs)
  {
    auto & vector_tags = obj->getFEVariableCoupleableVectorTags();
    needed_vector_tags.insert(vector_tags.begin(), vector_tags.end());
  }
  _fe_problem.setActiveFEVariableCoupleableVectorTags(needed_vector_tags, _tid);
}

Referenced by onNode().

Member Data Documentation

_aux_sys

AuxiliarySystem& ComputeNodalUserObjectsThread::_aux_sys

private

Definition at line 40 of file ComputeNodalUserObjectsThread.h.

Referenced by onNode().

_block_ids

std::set<SubdomainID> ComputeNodalUserObjectsThread::_block_ids

private

Definition at line 41 of file ComputeNodalUserObjectsThread.h.

Referenced by onNode().

_fe_problem

FEProblemBase& ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::_fe_problem

protectedinherited

Definition at line 72 of file ThreadedNodeLoop.h.

_query

const TheWarehouse::Query ComputeNodalUserObjectsThread::_query

private

Definition at line 39 of file ComputeNodalUserObjectsThread.h.

Referenced by onNode(), printGeneralExecutionInformation(), and subdomainChanged().

_tid

THREAD_ID ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::_tid

protectedinherited

Definition at line 73 of file ThreadedNodeLoop.h.

writable_variable_mutex

Threads::spin_mutex ComputeNodalUserObjectsThread::writable_variable_mutex

staticprivate

Definition at line 43 of file ComputeNodalUserObjectsThread.h.

---

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

• include/loops/ComputeNodalUserObjectsThread.h
• src/loops/ComputeNodalUserObjectsThread.C