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, std::vector< std::unique_ptr< NumericVector< Number > > > &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.
	~ComputeLinearFVLimitedGradientThread ()
void	operator() (const ElemInfoRange &range)
	Apply the limiter over the provided element 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.
std::vector< std::unique_ptr< NumericVector< Number > > > &	_gradient
	Gradient storage limited in place.
std::vector< Number * >	_gradient_data
	Writable local arrays, one per gradient component.
const bool	_owns_gradient_data
	True only for the original thread object that acquired and must restore the arrays.
const Moose::FV::GradientLimiterType	_limiter_type
	The type of limiter 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.

Detailed Description

Compute limited cell gradients for linear FV variables.

This thread currently supports gradients limited by scaling each cell gradient 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 60 of file ComputeLinearFVLimitedGradientThread.h.

Constructor & Destructor Documentation

ComputeLinearFVLimitedGradientThread() [1/2]

ComputeLinearFVLimitedGradientThread::ComputeLinearFVLimitedGradientThread	(	FEProblemBase &	fe_problem,
		SystemBase &	system,
		std::vector< std::unique_ptr< NumericVector< Number > > > &	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.
gradient	Gradient storage to limit in place.
limiter_type	The type of limiter which should be computed.
requested_variables	Variable numbers that requested this limiter.

Definition at line 25 of file ComputeLinearFVLimitedGradientThread.C.

  : _fe_problem(fe_problem),
    _dim(_fe_problem.mesh().dimension()),
    _system(system),
    _libmesh_system(system.system()),
    _system_number(_libmesh_system.number()),
    _gradient(gradient),
    _gradient_data(gradient.size()),
    _owns_gradient_data(true),
    _limiter_type(limiter_type),
    _requested_variables(requested_variables)
{
  for (const auto dim_index : index_range(_gradient))
  {
    auto & gradient_vector =
        libMesh::cast_ref<libMesh::PetscVector<Number> &>(*_gradient[dim_index]);
    _gradient_data[dim_index] = gradient_vector.get_array();
  }
}

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 50 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),
    _gradient(x._gradient),
    _gradient_data(x._gradient_data),
    _owns_gradient_data(false),
    _limiter_type(x._limiter_type),
    _requested_variables(x._requested_variables)
{
}

~ComputeLinearFVLimitedGradientThread()

ComputeLinearFVLimitedGradientThread::~ComputeLinearFVLimitedGradientThread

(

)

Definition at line 65 of file ComputeLinearFVLimitedGradientThread.C.

{
  if (_owns_gradient_data)
    for (const auto dim_index : index_range(_gradient))
    {
      auto & gradient_vector =
          libMesh::cast_ref<libMesh::PetscVector<Number> &>(*_gradient[dim_index]);
      gradient_vector.restore_array();
    }
}

Member Function Documentation

join()

void ComputeLinearFVLimitedGradientThread::join

(

const ComputeLinearFVLimitedGradientThread &

y

)

Join threads at the end of the execution.

Definition at line 215 of file ComputeLinearFVLimitedGradientThread.C.

{
}

operator()()

void ComputeLinearFVLimitedGradientThread::operator()

(

const ElemInfoRange &

range

)

Apply the limiter over the provided element range.

Parameters

range

The range of ElemInfos which should be computed.

Definition at line 77 of file ComputeLinearFVLimitedGradientThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;
 
  if (_limiter_type != Moose::FV::GradientLimiterType::Venkatakrishnan)
    mooseError("ComputeLinearFVLimitedGradientThread currently supports only the Venkatakrishnan "
               "limiter.");
 
  mooseAssert(_gradient.size() >= _dim,
              "Gradient container has fewer components than mesh dimension.");
 
  // All gradient component vectors have the same layout because they are
  // clones of the same system vector.
  auto & first_gradient_vector =
      libMesh::cast_ref<libMesh::PetscVector<Number> &>(*_gradient.front());
 
  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;
 
    PetscVectorReader solution_reader(*_libmesh_system.current_local_solution);
 
    for (auto elem_iterator = range.begin(); elem_iterator != range.end(); ++elem_iterator)
    {
      const auto & elem_info = *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;
 
      const auto local_dof = first_gradient_vector.map_global_to_local_index(dof);
 
      const Real phi_elem = solution_reader(dof);
      Real max_value = phi_elem;
      Real min_value = phi_elem;
 
      // Gather one-ring min/max solution 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);
      }
 
      // Copy this cell's raw gradient before modifying the gradient storage.
      VectorValue<Real> raw_grad;
      raw_grad.zero();
      for (const auto dim_index : make_range(_dim))
        raw_grad(dim_index) = _gradient_data[dim_index][local_dof];
 
      // If the stencil is constant (or nearly constant), leave the raw
      // gradient unchanged.
      if (std::abs(max_value - min_value) < 1e-14)
        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);
 
        const Real h = elem->hmin();
        const Real grad_mag = raw_grad.norm();
 
        const 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);
      }
 
      // No neighboring gradient values are needed, so it is safe to replace
      // this cell's raw gradient once its limiter coefficient is known.
      for (const auto dim_index : make_range(_dim))
        _gradient_data[dim_index][local_dof] = alpha * raw_grad(dim_index);
    }
  }
}

Member Data Documentation

_current_var

MooseLinearVariableFV<Real>* ComputeLinearFVLimitedGradientThread::_current_var

protected

Pointer to the current variable we are operating on.

Definition at line 110 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()().

_gradient

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

protected

Gradient storage limited in place.

Definition at line 86 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by ComputeLinearFVLimitedGradientThread(), operator()(), and ~ComputeLinearFVLimitedGradientThread().

_gradient_data

std::vector<Number *> ComputeLinearFVLimitedGradientThread::_gradient_data

protected

Writable local arrays, one per gradient component.

_gradient_data[component][local_dof] stores that component at a local DOF.

The original thread object acquires the arrays before threaded execution. Threaded copies share the pointers and write only to DOFs in their element range.

Definition at line 95 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by ComputeLinearFVLimitedGradientThread(), and 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 limiter requested.

Definition at line 101 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by operator()().

_owns_gradient_data

const bool ComputeLinearFVLimitedGradientThread::_owns_gradient_data

protected

True only for the original thread object that acquired and must restore the arrays.

Definition at line 98 of file ComputeLinearFVLimitedGradientThread.h.

Referenced by ~ComputeLinearFVLimitedGradientThread().

_requested_variables

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

protected

Variable numbers that requested the current limiter.

Definition at line 104 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()().

_tid

THREAD_ID ComputeLinearFVLimitedGradientThread::_tid

protected

Thread ID.

Definition at line 107 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