ComputeLinearFVLimitedGradientThread Class Reference

Compute limited cell gradients for linear FV variables. More...

#include <ComputeLinearFVLimitedGradientThread.h>

Public Types
using	ElemInfoRange = StoredRange< MooseMesh::const_elem_info_iterator, const ElemInfo * >

Public Member Functions
	ComputeLinearFVLimitedGradientThread (FEProblemBase &fe_problem, SystemBase &system, const std::vector< std::unique_ptr< NumericVector< Number >>> &raw_gradient, std::vector< std::unique_ptr< NumericVector< Number >>> &temporary_limited_gradient, const Moose::FV::GradientLimiterType limiter_type, const std::unordered_set< unsigned int > &requested_variables)
	Class constructor. More...
	ComputeLinearFVLimitedGradientThread (ComputeLinearFVLimitedGradientThread &x, Threads::split split)
	Splitting constructor. More...
void	operator() (const ElemInfoRange &range)
	Operator which is used to execute the thread over a certain iterator range. More...
void	join (const ComputeLinearFVLimitedGradientThread &y)
	Join threads at the end of the execution. More...

Protected Attributes
FEProblemBase &	_fe_problem
	Reference to the problem. More...
const unsigned int	_dim
	The dimension of the domain. More...
SystemBase &	_system
	The system wrapper this thread operates on. More...
const libMesh::System &	_libmesh_system
	Reference to the libMesh system backing the wrapper system. More...
const unsigned int	_system_number
	Global system number in the libMesh equation system. More...
const std::vector< std::unique_ptr< NumericVector< Number > > > &	_raw_gradient
	Reference to the raw gradient storage used as input for limiting. More...
const Moose::FV::GradientLimiterType	_limiter_type
	The type of the limiter we requested. More...
const std::unordered_set< unsigned int > &	_requested_variables
	Variable numbers that requested the current limiter. More...
THREAD_ID	_tid
	Thread ID. More...
MooseLinearVariableFV< Real > *	_current_var
	Pointer to the current variable we are operating on. More...
std::vector< std::unique_ptr< NumericVector< Number > > > &	_temporary_limited_gradient
	Reference to the temporary limited gradient storage. More...

Detailed Description

Compute limited cell gradients for linear FV variables.

This thread currently supports limited gradients produced by scaling the raw Green-Gauss gradients with a per-cell limiter coefficient (e.g. Venkatakrishnan).

Definition at line 32 of file ComputeLinearFVLimitedGradientThread.h.

Member Typedef Documentation

ElemInfoRange

using ComputeLinearFVLimitedGradientThread::ElemInfoRange = StoredRange<MooseMesh::const_elem_info_iterator, const ElemInfo *>

Definition at line 61 of file ComputeLinearFVLimitedGradientThread.h.

Constructor & Destructor Documentation

ComputeLinearFVLimitedGradientThread() [1/2]

ComputeLinearFVLimitedGradientThread::ComputeLinearFVLimitedGradientThread	(	FEProblemBase &	fe_problem,
		SystemBase &	system,
		const std::vector< std::unique_ptr< NumericVector< Number >>> &	raw_gradient,
		std::vector< std::unique_ptr< NumericVector< Number >>> &	temporary_limited_gradient,
		const Moose::FV::GradientLimiterType	limiter_type,
		const std::unordered_set< unsigned int > &	requested_variables
	)

Class constructor.

Parameters

fe_problem	Reference to the problem
system	The system whose variables are assembled by this thread.
raw_gradient	The raw gradient container used as limiter input.
temporary_limited_gradient	Scratch storage for limited gradients being assembled (used as output as well, but later swapped with another container).
limiter_type	The type of the limiter which should be computed.
requested_variables	Variable numbers that requested this limiter.

Definition at line 24 of file ComputeLinearFVLimitedGradientThread.C.

  : _fe_problem(fe_problem),
    _dim(_fe_problem.mesh().dimension()),
    _system(system),
    _libmesh_system(system.system()),
    _system_number(_libmesh_system.number()),
    _raw_gradient(raw_gradient),
    _limiter_type(limiter_type),
    _requested_variables(requested_variables),
    _temporary_limited_gradient(temporary_limited_gradient)
{
}

ComputeLinearFVLimitedGradientThread() [2/2]

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

Splitting constructor.

Parameters

x	Reference to the other thread
split	The thread split

Definition at line 43 of file ComputeLinearFVLimitedGradientThread.C.

  : _fe_problem(x._fe_problem),
    _dim(x._dim),
    _system(x._system),
    _libmesh_system(x._libmesh_system),
    _system_number(x._system_number),
    _raw_gradient(x._raw_gradient),
    _limiter_type(x._limiter_type),
    _requested_variables(x._requested_variables),
    _temporary_limited_gradient(x._temporary_limited_gradient)
{
}

Member Function Documentation

join()

void ComputeLinearFVLimitedGradientThread::join

(

const ComputeLinearFVLimitedGradientThread &

y

)

Join threads at the end of the execution.

Definition at line 218 of file ComputeLinearFVLimitedGradientThread.C.

{
}

operator()()

void ComputeLinearFVLimitedGradientThread::operator()

(

const ElemInfoRange &

range

)

Operator which is used to execute the thread over a certain iterator range.

Parameters

range

The range of ElemInfos which should be computed.

Definition at line 58 of file ComputeLinearFVLimitedGradientThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;

  const auto & raw_grad_container = _raw_gradient;

  if (_limiter_type != Moose::FV::GradientLimiterType::Venkatakrishnan)
    mooseError("ComputeLinearFVLimitedGradientThread currently supports only the Venkatakrishnan "
               "limiter.");

  unsigned int size = 0;

  for (const auto & variable : _system.getVariables(_tid))
  {
    _current_var = dynamic_cast<MooseLinearVariableFV<Real> *>(variable);
    if (!_current_var)
      continue;

    if (!_current_var->needsGradientVectorStorage())
      continue;

    if (!_requested_variables.count(_current_var->number()))
      continue;

    if (!size)
      size = range.size();

    std::vector<std::vector<Real>> temporary_values(_temporary_limited_gradient.size(),
                                                    std::vector<Real>(size, 0.0));
    std::vector<dof_id_type> dof_indices(size, 0);

    PetscVectorReader solution_reader(*_libmesh_system.current_local_solution);
    std::vector<PetscVectorReader> grad_reader;
    grad_reader.reserve(raw_grad_container.size());
    for (const auto dim_index : index_range(raw_grad_container))
      grad_reader.emplace_back(*raw_grad_container[dim_index]);

    mooseAssert(raw_grad_container.size() >= _dim,
                "Raw gradient container has fewer components than mesh dimension.");
    mooseAssert(_temporary_limited_gradient.size() >= _dim,
                "Limited gradient container has fewer components than mesh dimension.");

    auto elem_iterator = range.begin();
    for (const auto elem_i : make_range(size))
    {
      const auto & elem_info = *elem_iterator;
      elem_iterator++;

      if (!_current_var->hasBlocks(elem_info->subdomain_id()))
        continue;

      const dof_id_type dof = elem_info->dofIndices()[_system_number][_current_var->number()];
      if (dof == libMesh::DofObject::invalid_id)
        continue;

      dof_indices[elem_i] = dof;

      const Real phi_elem = solution_reader(dof);
      Real max_value = phi_elem;
      Real min_value = phi_elem;

      // Gather one-ring min/max values.
      const Elem * const elem = elem_info->elem();
      for (const auto side : make_range(elem->n_sides()))
      {
        const Elem * const neighbor = elem->neighbor_ptr(side);
        if (!neighbor)
          continue;

        const auto & neighbor_info = _fe_problem.mesh().elemInfo(neighbor->id());
        if (!_current_var->hasBlocks(neighbor_info.subdomain_id()))
          continue;

        const dof_id_type neighbor_dof =
            neighbor_info.dofIndices()[_system_number][_current_var->number()];
        if (neighbor_dof == libMesh::DofObject::invalid_id)
          continue;

        const Real phi_neighbor = solution_reader(neighbor_dof);
        max_value = std::max(max_value, phi_neighbor);
        min_value = std::min(min_value, phi_neighbor);
      }

      // Read the raw cell gradient.
      VectorValue<Real> raw_grad;
      raw_grad.zero();
      for (const auto dim_index : make_range(_dim))
        raw_grad(dim_index) = grad_reader[dim_index](dof);

      // If the stencil is constant (or nearly constant), don't attempt to limit.
      if (std::abs(max_value - min_value) < 1e-14)
      {
        for (const auto dim_index : make_range(_dim))
          temporary_values[dim_index][elem_i] = raw_grad(dim_index);
        continue;
      }

      Real alpha = 1.0;
      const Point & elem_centroid = elem_info->centroid();

      for (const auto side : make_range(elem->n_sides()))
      {
        const Elem * const neighbor = elem->neighbor_ptr(side);
        if (!neighbor)
          continue;

        const auto & neighbor_info = _fe_problem.mesh().elemInfo(neighbor->id());
        if (!_current_var->hasBlocks(neighbor_info.subdomain_id()))
          continue;

        const dof_id_type neighbor_dof =
            neighbor_info.dofIndices()[_system_number][_current_var->number()];
        if (neighbor_dof == libMesh::DofObject::invalid_id)
          continue;

        const bool elem_has_face_info = Moose::FV::elemHasFaceInfo(*elem, neighbor);
        const Elem * const fi_elem = elem_has_face_info ? elem : neighbor;
        const unsigned int fi_side =
            elem_has_face_info ? side : neighbor->which_neighbor_am_i(elem);
        const auto * fi = _fe_problem.mesh().faceInfo(fi_elem, fi_side);
        mooseAssert(fi,
                    "Missing FaceInfo for neighboring elements with centroid " +
                        Moose::stringify(elem_info->centroid()) + " and " +
                        Moose::stringify(neighbor->vertex_average()) +
                        " while computing limited gradients.");

        const Point face_point = fi->faceCentroid();

        const Real delta_face = raw_grad * (face_point - elem_centroid);

        Real h = elem->hmin();
        Real grad_mag = raw_grad.norm();

        Real eps = 0.1 * (grad_mag * h) * (grad_mag * h) + 1e-20;

        const Real delta_max = std::abs(max_value - phi_elem) + eps;
        const Real delta_min = std::abs(min_value - phi_elem) + eps;

        const Real rf = (delta_face >= 0.0) ? std::abs(delta_face) / delta_max
                                            : std::abs(delta_face) / delta_min;

        const Real beta = (2.0 * rf + 1.0) / (rf * (2.0 * rf + 1.0) + 1.0);
        alpha = std::min(alpha, beta);
      }

      const VectorValue<Real> limited_grad = alpha * raw_grad;
      for (const auto dim_index : make_range(_dim))
        temporary_values[dim_index][elem_i] = limited_grad(dim_index);
    }

    for (const auto dim_index : make_range(_dim))
    {
      _temporary_limited_gradient[dim_index]->add_vector(temporary_values[dim_index].data(),
                                                         dof_indices);
    }
  }
}

Member Data Documentation

_current_var

MooseLinearVariableFV<Real>* ComputeLinearFVLimitedGradientThread::_current_var

protected

Pointer to the current variable we are operating on.

Definition at line 98 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_dim

const unsigned int ComputeLinearFVLimitedGradientThread::_dim

protected

The dimension of the domain.

Definition at line 74 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_fe_problem

FEProblemBase& ComputeLinearFVLimitedGradientThread::_fe_problem

protected

Reference to the problem.

Definition at line 71 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_libmesh_system

const libMesh::System& ComputeLinearFVLimitedGradientThread::_libmesh_system

protected

Reference to the libMesh system backing the wrapper system.

Definition at line 80 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_limiter_type

const Moose::FV::GradientLimiterType ComputeLinearFVLimitedGradientThread::_limiter_type

protected

The type of the limiter we requested.

Definition at line 89 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_raw_gradient

const std::vector<std::unique_ptr<NumericVector<Number> > >& ComputeLinearFVLimitedGradientThread::_raw_gradient

protected

Reference to the raw gradient storage used as input for limiting.

Definition at line 86 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_requested_variables

const std::unordered_set<unsigned int>& ComputeLinearFVLimitedGradientThread::_requested_variables

protected

Variable numbers that requested the current limiter.

Definition at line 92 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_system

SystemBase& ComputeLinearFVLimitedGradientThread::_system

protected

The system wrapper this thread operates on.

Definition at line 77 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_system_number

const unsigned int ComputeLinearFVLimitedGradientThread::_system_number

protected

Global system number in the libMesh equation system.

Definition at line 83 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_temporary_limited_gradient

std::vector<std::unique_ptr<NumericVector<Number> > >& ComputeLinearFVLimitedGradientThread::_temporary_limited_gradient

protected

Reference to the temporary limited gradient storage.

Definition at line 101 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_tid

THREAD_ID ComputeLinearFVLimitedGradientThread::_tid

protected

Thread ID.

Definition at line 95 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

---

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

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