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.
	ComputeLinearFVLimitedGradientThread (ComputeLinearFVLimitedGradientThread &x, Threads::split split)
	Splitting constructor.
void	operator() (const ElemInfoRange &range)
	Operator which is used to execute the thread over a certain iterator range.
void	join (const ComputeLinearFVLimitedGradientThread &y)
	Join threads at the end of the execution.

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

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