void
ComputeUserObjectsThread::onInternalSide(const Elem * elem, unsigned int side)
{
// Pointer to the neighbor we are currently working on.
const Elem * neighbor = elem->neighbor_ptr(side);
// Get the global id of the element and the neighbor
const dof_id_type elem_id = elem->id(), neighbor_id = neighbor->id();
if (!_internal_side_user_objects.hasActiveBlockObjects(_subdomain, _tid))
return;
if (!((neighbor->active() && (neighbor->level() == elem->level()) && (elem_id < neighbor_id)) ||
(neighbor->level() < elem->level())))
return;
_fe_problem.prepareFace(elem, _tid);
_fe_problem.reinitNeighbor(elem, side, _tid);
// Set up Sentinels so that, even if one of the reinitMaterialsXXX() calls throws, we
// still remember to swap back during stack unwinding.
SwapBackSentinel face_sentinel(_fe_problem, &FEProblem::swapBackMaterialsFace, _tid);
_fe_problem.reinitMaterialsFace(elem->subdomain_id(), _tid);
SwapBackSentinel neighbor_sentinel(_fe_problem, &FEProblem::swapBackMaterialsNeighbor, _tid);
_fe_problem.reinitMaterialsNeighbor(neighbor->subdomain_id(), _tid);
const auto & objects = _internal_side_user_objects.getActiveBlockObjects(_subdomain, _tid);
for (const auto & uo : objects)
{
if (!uo->blockRestricted())
uo->execute();
else if (uo->hasBlocks(neighbor->subdomain_id()))
uo->execute();
}
}
void
ComputeResidualThread::onInterface(const Elem * elem, unsigned int side, BoundaryID bnd_id)
{
if (_interface_kernels.hasActiveBoundaryObjects(bnd_id, _tid))
{
// Pointer to the neighbor we are currently working on.
const Elem * neighbor = elem->neighbor_ptr(side);
if (neighbor->active())
{
_fe_problem.reinitNeighbor(elem, side, _tid);
// Set up Sentinels so that, even if one of the reinitMaterialsXXX() calls throws, we
// still remember to swap back during stack unwinding.
SwapBackSentinel face_sentinel(_fe_problem, &FEProblem::swapBackMaterialsFace, _tid);
_fe_problem.reinitMaterialsFace(elem->subdomain_id(), _tid);
SwapBackSentinel neighbor_sentinel(_fe_problem, &FEProblem::swapBackMaterialsNeighbor, _tid);
_fe_problem.reinitMaterialsNeighbor(neighbor->subdomain_id(), _tid);
const auto & int_ks = _interface_kernels.getActiveBoundaryObjects(bnd_id, _tid);
for (const auto & interface_kernel : int_ks)
interface_kernel->computeResidual();
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
_fe_problem.addResidualNeighbor(_tid);
}
}
}
}
void
ComputeIndicatorThread::onInternalSide(const Elem * elem, unsigned int side)
{
if (_finalize) // If finalizing we only do something on the elements
return;
// Pointer to the neighbor we are currently working on.
const Elem * neighbor = elem->neighbor_ptr(side);
// Get the global id of the element and the neighbor
const dof_id_type elem_id = elem->id(), neighbor_id = neighbor->id();
if ((neighbor->active() && (neighbor->level() == elem->level()) && (elem_id < neighbor_id)) ||
(neighbor->level() < elem->level()))
{
for (const auto & it : _aux_sys._elem_vars[_tid])
{
MooseVariable * var = it.second;
var->prepareAux();
}
SubdomainID block_id = elem->subdomain_id();
if (_internal_side_indicators.hasActiveBlockObjects(block_id, _tid))
{
_fe_problem.reinitNeighbor(elem, side, _tid);
// Set up Sentinels so that, even if one of the reinitMaterialsXXX() calls throws, we
// still remember to swap back during stack unwinding.
SwapBackSentinel face_sentinel(_fe_problem, &FEProblemBase::swapBackMaterialsFace, _tid);
_fe_problem.reinitMaterialsFace(block_id, _tid);
SwapBackSentinel neighbor_sentinel(
_fe_problem, &FEProblemBase::swapBackMaterialsNeighbor, _tid);
_fe_problem.reinitMaterialsNeighbor(neighbor->subdomain_id(), _tid);
const std::vector<std::shared_ptr<InternalSideIndicator>> & indicators =
_internal_side_indicators.getActiveBlockObjects(block_id, _tid);
for (const auto & indicator : indicators)
indicator->computeIndicator();
}
}
}
void
ComputeResidualThread::onInternalSide(const Elem * elem, unsigned int side)
{
if (_dg_kernels.hasActiveBlockObjects(_subdomain, _tid))
{
// Pointer to the neighbor we are currently working on.
const Elem * neighbor = elem->neighbor_ptr(side);
// Get the global id of the element and the neighbor
const dof_id_type elem_id = elem->id(), neighbor_id = neighbor->id();
if ((neighbor->active() && (neighbor->level() == elem->level()) && (elem_id < neighbor_id)) ||
(neighbor->level() < elem->level()))
{
_fe_problem.reinitNeighbor(elem, side, _tid);
// Set up Sentinels so that, even if one of the reinitMaterialsXXX() calls throws, we
// still remember to swap back during stack unwinding.
SwapBackSentinel face_sentinel(_fe_problem, &FEProblem::swapBackMaterialsFace, _tid);
_fe_problem.reinitMaterialsFace(elem->subdomain_id(), _tid);
SwapBackSentinel neighbor_sentinel(_fe_problem, &FEProblem::swapBackMaterialsNeighbor, _tid);
_fe_problem.reinitMaterialsNeighbor(neighbor->subdomain_id(), _tid);
const auto & dgks = _dg_kernels.getActiveBlockObjects(_subdomain, _tid);
for (const auto & dg_kernel : dgks)
if (dg_kernel->hasBlocks(neighbor->subdomain_id()))
dg_kernel->computeResidual();
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
_fe_problem.addResidualNeighbor(_tid);
}
}
}
}
