BoundaryElemIntegrityCheckThread Class Reference

#include <BoundaryElemIntegrityCheckThread.h>

Public Member Functions
	BoundaryElemIntegrityCheckThread (FEProblemBase &fe_problem, const TheWarehouse::Query &query)
	BoundaryElemIntegrityCheckThread (BoundaryElemIntegrityCheckThread &x, Threads::split split)
void	operator() (const ConstBndElemRange &range)
void	join (const BoundaryElemIntegrityCheckThread &)

Protected Attributes
FEProblemBase &	_fe_problem
	the finite element (or volume) problem More...
const AuxiliarySystem &	_aux_sys
	The auxiliary system to whom we'll delegate the boundary variable dependency integrity check. More...
const ExecuteMooseObjectWarehouse< AuxKernel > &	_elem_aux
	Elemental auxiliary kernels acting on standard field variables. More...
const ExecuteMooseObjectWarehouse< VectorAuxKernel > &	_elem_vec_aux
	Elemental auxiliary kernels acting on vector field variables. More...
const ExecuteMooseObjectWarehouse< ArrayAuxKernel > &	_elem_array_aux
	Elemental auxiliary kernels acting on array field variables. More...
const TheWarehouse::Query &	_query
	A warehouse query that we will use to obtain user objects for boundary variable dependency integrity checks. More...

Detailed Description

Definition at line 32 of file BoundaryElemIntegrityCheckThread.h.

Constructor & Destructor Documentation

BoundaryElemIntegrityCheckThread() [1/2]

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

Definition at line 26 of file BoundaryElemIntegrityCheckThread.C.

  : _fe_problem(fe_problem),
    _aux_sys(fe_problem.getAuxiliarySystem()),
    _elem_aux(_aux_sys.elemAuxWarehouse()),
    _elem_vec_aux(_aux_sys.elemVectorAuxWarehouse()),
    _elem_array_aux(_aux_sys.elemArrayAuxWarehouse()),
    _query(query)
{
}

BoundaryElemIntegrityCheckThread() [2/2]

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

Definition at line 38 of file BoundaryElemIntegrityCheckThread.C.

  : _fe_problem(x._fe_problem),
    _aux_sys(x._aux_sys),
    _elem_aux(x._elem_aux),
    _elem_vec_aux(x._elem_vec_aux),
    _elem_array_aux(x._elem_array_aux),
    _query(x._query)
{
}

Member Function Documentation

join()

void BoundaryElemIntegrityCheckThread::join

(

const BoundaryElemIntegrityCheckThread &

)

Definition at line 130 of file BoundaryElemIntegrityCheckThread.C.

{
}

operator()()

void BoundaryElemIntegrityCheckThread::operator()

(

const ConstBndElemRange &

range

)

Definition at line 50 of file BoundaryElemIntegrityCheckThread.C.

{
  ParallelUniqueId puid;
  const auto tid = puid.id;

  for (const auto & belem : range)
  {
    const Elem * elem = belem->_elem;
    const auto boundary_id = belem->_bnd_id;
    const auto side = belem->_side;

    // We can distribute work just as the actual execution code will
    if (elem->processor_id() != _fe_problem.processor_id())
      return;

    auto & mesh = _fe_problem.mesh();

    const auto & bnd_name = mesh.getBoundaryName(boundary_id);

    // uo check
    std::vector<SideUserObject *> objs;
    _query.clone()
        .condition<AttribThread>(tid)
        .condition<AttribInterfaces>(Interfaces::SideUserObject)
        .condition<AttribBoundaries>(boundary_id, true)
        .queryInto(objs);
    for (const auto & uo : objs)
      if (uo->checkVariableBoundaryIntegrity())
      {
        auto leftover_vars = uo->checkAllVariables(*elem);
        if (!leftover_vars.empty())
        {
          const auto neighbor = elem->neighbor_ptr(side);
          const bool upwind_elem = !neighbor || elem->id() < neighbor->id();
          const Elem * lower_d_elem =
              upwind_elem ? mesh.getLowerDElem(elem, side)
                          : mesh.getLowerDElem(neighbor, neighbor->which_neighbor_am_i(elem));
          if (lower_d_elem)
            leftover_vars = uo->checkVariables(*lower_d_elem, leftover_vars);
        }
        boundaryIntegrityCheckError(*uo, leftover_vars, bnd_name);
      }

    auto check = [elem, boundary_id, &bnd_name, tid, &mesh, side](const auto & warehouse)
    {
      if (!warehouse.hasBoundaryObjects(boundary_id, tid))
        return;

      const auto & bnd_objects = warehouse.getBoundaryObjects(boundary_id, tid);
      for (const auto & bnd_object : bnd_objects)
        // Skip if this object uses geometric search because coupled variables may be defined on
        // paired boundaries instead of the boundary this elem is on
        if (!bnd_object->requiresGeometricSearch() && bnd_object->checkVariableBoundaryIntegrity())
        {
          // First check the higher-dimensional element
          auto leftover_vars = bnd_object->checkAllVariables(*elem);
          if (!leftover_vars.empty())
          {
            const auto neighbor = elem->neighbor_ptr(side);
            const bool upwind_elem = !neighbor || elem->id() < neighbor->id();
            const Elem * lower_d_elem =
                upwind_elem ? mesh.getLowerDElem(elem, side)
                            : mesh.getLowerDElem(neighbor, neighbor->which_neighbor_am_i(elem));
            if (lower_d_elem)
              leftover_vars = bnd_object->checkVariables(*lower_d_elem, leftover_vars);
          }

          boundaryIntegrityCheckError(*bnd_object, leftover_vars, bnd_name);
        }
    };

    check(_elem_aux);
    check(_elem_vec_aux);
    check(_elem_array_aux);
    for (const auto i : make_range(_fe_problem.numNonlinearSystems()))
      check(_fe_problem.getNonlinearSystemBase(i).getIntegratedBCWarehouse());
  }
}

Member Data Documentation

_aux_sys

const AuxiliarySystem& BoundaryElemIntegrityCheckThread::_aux_sys

protected

The auxiliary system to whom we'll delegate the boundary variable dependency integrity check.

Definition at line 49 of file BoundaryElemIntegrityCheckThread.h.

_elem_array_aux

const ExecuteMooseObjectWarehouse<ArrayAuxKernel>& BoundaryElemIntegrityCheckThread::_elem_array_aux

protected

Elemental auxiliary kernels acting on array field variables.

Definition at line 58 of file BoundaryElemIntegrityCheckThread.h.

Referenced by operator()().

_elem_aux

const ExecuteMooseObjectWarehouse<AuxKernel>& BoundaryElemIntegrityCheckThread::_elem_aux

protected

Elemental auxiliary kernels acting on standard field variables.

Definition at line 52 of file BoundaryElemIntegrityCheckThread.h.

Referenced by operator()().

_elem_vec_aux

const ExecuteMooseObjectWarehouse<VectorAuxKernel>& BoundaryElemIntegrityCheckThread::_elem_vec_aux

protected

Elemental auxiliary kernels acting on vector field variables.

Definition at line 55 of file BoundaryElemIntegrityCheckThread.h.

Referenced by operator()().

_fe_problem

FEProblemBase& BoundaryElemIntegrityCheckThread::_fe_problem

protected

the finite element (or volume) problem

Definition at line 46 of file BoundaryElemIntegrityCheckThread.h.

Referenced by operator()().

_query

const TheWarehouse::Query& BoundaryElemIntegrityCheckThread::_query

protected

A warehouse query that we will use to obtain user objects for boundary variable dependency integrity checks.

Definition at line 62 of file BoundaryElemIntegrityCheckThread.h.

Referenced by operator()().

---

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

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