The gradient in a volume using Green Gauss theorem and a cell-centered finite-volume approximation can be computed as follows: More...

#include <ComputeLinearFVGreenGaussGradientVolumeThread.h>

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

Public Member Functions
	ComputeLinearFVGreenGaussGradientVolumeThread (FEProblemBase &fe_problem, SystemBase &system, std::vector< std::unique_ptr< NumericVector< Number > > > &gradient, const std::unordered_set< unsigned int > &gradient_variables)
	Class constructor.

	ComputeLinearFVGreenGaussGradientVolumeThread (ComputeLinearFVGreenGaussGradientVolumeThread &x, Threads::split split)
	Splitting constructor.

	~ComputeLinearFVGreenGaussGradientVolumeThread ()

void	operator() (const ElemInfoRange &range)
	Operator which is used to execute the thread over a certain iterator range.

void	join (const ComputeLinearFVGreenGaussGradientVolumeThread &y)
	Join threads at the end of the execution.

Protected Attributes
FEProblemBase &	_fe_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.

const unsigned int	_system_number
	Global system number.

THREAD_ID	_tid
	Thread ID.

MooseLinearVariableFV< Real > *	_current_var
	Pointer to the current variable.

std::vector< std::unique_ptr< NumericVector< Number > > > &	_gradient
	Normalized (by cell volume) gradients to write into.

std::vector< Real * >	_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 std::unordered_set< unsigned int > &	_gradient_variables
	Indices of the variables this producer should compute gradients for.

Detailed Description

The gradient in a volume using Green Gauss theorem and a cell-centered finite-volume approximation can be computed as follows:

\nabla u \approx \frac{1}{V_C} \sum_f u_f\vec{n}_f,

where V_C denotes the volume of the cell, f is a face iterator, while u_f and \vec{S}_f are the face value of the variable and surface area vector (the product of the surface area and normals), respectively. This object carries out the normalization with the element volumes.

Furthermore, in cylindrical coordinates, the radial value of the gradient needs to be extended with a u(r)/r value which is added in this object as well.

Definition at line 40 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Member Typedef Documentation

◆ ElemInfoRange

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

Definition at line 66 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Constructor & Destructor Documentation

◆ ComputeLinearFVGreenGaussGradientVolumeThread() [1/2]

ComputeLinearFVGreenGaussGradientVolumeThread::ComputeLinearFVGreenGaussGradientVolumeThread	(	FEProblemBase &	fe_problem,
		SystemBase &	system,
		std::vector< std::unique_ptr< NumericVector< Number > > > &	gradient,
		const std::unordered_set< unsigned int > &	gradient_variables
	)

Class constructor.

Parameters

fe_problem	Reference to the problem
system	The system which contains variables that need gradients.
input_gradient	Scratch storage holding the unnormalized face sums.
output_gradient	Storage where normalized (with element volume) gradients are written.

Definition at line 16 of file ComputeLinearFVGreenGaussGradientVolumeThread.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),
    _gradient_variables(gradient_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();
  }
}

◆ ComputeLinearFVGreenGaussGradientVolumeThread() [2/2]

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

Splitting constructor.

Parameters

x	Reference to the other bodies
split	The thread split

Definition at line 39 of file ComputeLinearFVGreenGaussGradientVolumeThread.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),
    _gradient_variables(x._gradient_variables)
{
}

◆ ~ComputeLinearFVGreenGaussGradientVolumeThread()

ComputeLinearFVGreenGaussGradientVolumeThread::~ComputeLinearFVGreenGaussGradientVolumeThread ( )

Definition at line 53 of file ComputeLinearFVGreenGaussGradientVolumeThread.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 ComputeLinearFVGreenGaussGradientVolumeThread::join ( const ComputeLinearFVGreenGaussGradientVolumeThread & y )

Join threads at the end of the execution.

Parameters

y	Reference to the other bodies

Definition at line 121 of file ComputeLinearFVGreenGaussGradientVolumeThread.C.

123{

124}

◆ operator()()

void ComputeLinearFVGreenGaussGradientVolumeThread::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 65 of file ComputeLinearFVGreenGaussGradientVolumeThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;
 
  for (const auto & variable : _system.getVariables(_tid))
  {
    _current_var = dynamic_cast<MooseLinearVariableFV<Real> *>(variable);
    if (!_current_var)
      continue;
 
    if (!_gradient_variables.count(_current_var->number()))
      continue;
 
    const auto rz_radial_coord = _fe_problem.mesh().getAxisymmetricRadialCoord();
    const auto state = Moose::currentState();
 
    // All component vectors are clones of the same system vector and therefore
    // have the same local indexing.
    auto & first_gradient_vector =
        libMesh::cast_ref<libMesh::PetscVector<Number> &>(*_gradient.front());
 
    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 auto coord_type = _fe_problem.mesh().getCoordSystem(elem_info->subdomain_id());
 
      mooseAssert(coord_type != Moose::CoordinateSystemType::COORD_RSPHERICAL,
                  "We have not yet implemented the correct translation from gradient to "
                  "divergence for spherical coordinates yet.");
 
      const dof_id_type dof = elem_info->dofIndices()[_system_number][_current_var->number()];
      const auto local_dof = first_gradient_vector.map_global_to_local_index(dof);
 
      const auto volume = elem_info->volume() * elem_info->coordFactor();
 
      for (const auto dim_index : index_range(_gradient))
        _gradient_data[dim_index][local_dof] /= volume;
 
      if (coord_type == Moose::CoordinateSystemType::COORD_RZ)
      {
        mooseAssert(elem_info->centroid()(rz_radial_coord) != 0,
                    "Axisymmetric control volumes should not have a zero radial coordinate");
 
        _gradient_data[rz_radial_coord][local_dof] -=
            _current_var->getElemValue(*elem_info, state) / elem_info->centroid()(rz_radial_coord);
      }
    }
  }
}

Member Data Documentation

◆ _current_var

MooseLinearVariableFV<Real>* ComputeLinearFVGreenGaussGradientVolumeThread::_current_var

protected

Pointer to the current variable.

Definition at line 95 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

◆ _dim

const unsigned int ComputeLinearFVGreenGaussGradientVolumeThread::_dim

protected

The dimension of the domain.

Definition at line 80 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

◆ _fe_problem

FEProblemBase& ComputeLinearFVGreenGaussGradientVolumeThread::_fe_problem

protected

Definition at line 77 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

◆ _gradient

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

protected

Normalized (by cell volume) gradients to write into.

Definition at line 98 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

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

◆ _gradient_data

std::vector<Real *> ComputeLinearFVGreenGaussGradientVolumeThread::_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 107 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by ComputeLinearFVGreenGaussGradientVolumeThread(), and operator()().