ComputeLinearFVGreenGaussGradientVolumeThread Class Reference

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, const unsigned int linear_system_num)
	Class constructor. More...
	ComputeLinearFVGreenGaussGradientVolumeThread (ComputeLinearFVGreenGaussGradientVolumeThread &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 ComputeLinearFVGreenGaussGradientVolumeThread &y)
	Join threads at the end of the execution. More...

Protected Attributes
FEProblemBase &	_fe_problem
const unsigned int	_dim
	The dimension of the domain. More...
const unsigned int	_linear_system_number
	The number of the linear system on which this thread is acting. More...
const libMesh::LinearImplicitSystem &	_linear_system
	Reference to the linear system at libmesh level. More...
const unsigned int	_system_number
	Global system number. More...
THREAD_ID	_tid
	Thread ID. More...
MooseLinearVariableFV< Real > *	_current_var
	Pointer to the current variable. More...

Detailed Description

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

u {1}{V_C} u_f{n}_f,

where V_C denotes the volume of the cell, f is a face iterator, while u_f and {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 37 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Member Typedef Documentation

ElemInfoRange

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

Definition at line 56 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Constructor & Destructor Documentation

ComputeLinearFVGreenGaussGradientVolumeThread() [1/2]

ComputeLinearFVGreenGaussGradientVolumeThread::ComputeLinearFVGreenGaussGradientVolumeThread	(	FEProblemBase &	fe_problem,
		const unsigned int	linear_system_num
	)

Class constructor.

Parameters

fe_problem	Reference to the problem
linear_system_num	The number of the linear system which contains variables that need gradients.

Definition at line 16 of file ComputeLinearFVGreenGaussGradientVolumeThread.C.

  : _fe_problem(fe_problem),
    _dim(_fe_problem.mesh().dimension()),
    _linear_system_number(linear_system_num),
    _linear_system(libMesh::cast_ref<libMesh::LinearImplicitSystem &>(
        _fe_problem.getLinearSystem(_linear_system_number).system())),
    _system_number(_linear_system.number())
{
}

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 27 of file ComputeLinearFVGreenGaussGradientVolumeThread.C.

  : _fe_problem(x._fe_problem),
    _dim(x._dim),
    _linear_system_number(x._linear_system_number),
    _linear_system(x._linear_system),
    _system_number(x._system_number)
{
}

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 114 of file ComputeLinearFVGreenGaussGradientVolumeThread.C.

{
}

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 38 of file ComputeLinearFVGreenGaussGradientVolumeThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;

  auto & linear_system = _fe_problem.getLinearSystem(_linear_system_number);

  // This will be the vector we work on since the old gradient might still be needed
  // to compute extrapolated boundary conditions for example.
  auto & grad_container = linear_system.newGradientContainer();

  // Computing this size can be very expensive so we only want to do it once
  unsigned int size = 0;

  for (const auto & variable : linear_system.getVariables(_tid))
  {
    _current_var = dynamic_cast<MooseLinearVariableFV<Real> *>(variable);
    mooseAssert(_current_var,
                "This should be a linear FV variable, did we somehow add a nonlinear variable to "
                "the linear system?");
    if (_current_var->needsGradientVectorStorage())
    {
      if (!size)
        size = range.size();

      const auto rz_radial_coord = _fe_problem.mesh().getAxisymmetricRadialCoord();
      const auto state = Moose::currentState();

      std::vector<std::vector<Real>> new_values(grad_container.size(),
                                                std::vector<Real>(size, 0.0));
      std::vector<dof_id_type> dof_indices(size, 0);
      {
        std::vector<PetscVectorReader> grad_reader;
        for (const auto dim_index : index_range(grad_container))
          grad_reader.emplace_back(*grad_container[dim_index]);

        // Iterate over all the elements in the range
        auto elem_iterator = range.begin();
        for (const auto elem_i : make_range(size))
        {
          const auto & elem_info = *elem_iterator;
          if (_current_var->hasBlocks(elem_info->subdomain_id()))
          {
            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.");

            dof_indices[elem_i] = elem_info->dofIndices()[_system_number][_current_var->number()];
            const auto volume = elem_info->volume() * elem_info->coordFactor();

            for (const auto dim_index : index_range(grad_container))
              new_values[dim_index][elem_i] = grad_reader[dim_index](dof_indices[elem_i]) / volume;

            if (coord_type == Moose::CoordinateSystemType::COORD_RZ)
            {
              const auto radial_contrib = _current_var->getElemValue(*elem_info, state) /
                                          elem_info->centroid()(rz_radial_coord);
              new_values[rz_radial_coord][elem_i] += radial_contrib;
            }
          }
          elem_iterator++;
        }
      }
      for (const auto dim_index : index_range(grad_container))
      {
        grad_container[dim_index]->zero();
        grad_container[dim_index]->add_vector(new_values[dim_index].data(), dof_indices);
      }
    }
  }
}

Member Data Documentation

_current_var

MooseLinearVariableFV<Real>* ComputeLinearFVGreenGaussGradientVolumeThread::_current_var

protected

Pointer to the current variable.

Definition at line 85 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_dim

const unsigned int ComputeLinearFVGreenGaussGradientVolumeThread::_dim

protected

The dimension of the domain.

Definition at line 70 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

_fe_problem

FEProblemBase& ComputeLinearFVGreenGaussGradientVolumeThread::_fe_problem

protected

Definition at line 67 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_linear_system

const libMesh::LinearImplicitSystem& ComputeLinearFVGreenGaussGradientVolumeThread::_linear_system

protected

Reference to the linear system at libmesh level.

Definition at line 76 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

_linear_system_number

const unsigned int ComputeLinearFVGreenGaussGradientVolumeThread::_linear_system_number

protected

The number of the linear system on which this thread is acting.

Definition at line 73 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_system_number

const unsigned int ComputeLinearFVGreenGaussGradientVolumeThread::_system_number

protected

Global system number.

Definition at line 79 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_tid

THREAD_ID ComputeLinearFVGreenGaussGradientVolumeThread::_tid

protected

Thread ID.

Definition at line 82 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

---

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

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