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, SystemBase &system, std::vector< std::unique_ptr< NumericVector< Number >>> &temporary_gradient)
	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...
SystemBase &	_system
	The system wrapper this thread operates on. More...
const libMesh::System &	_libmesh_system
	Reference to the libmesh system. 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...
std::vector< std::unique_ptr< NumericVector< Number > > > &	_temporary_gradient
	Cache for the temporary gradient being built. 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 38 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Member Typedef Documentation

ElemInfoRange

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

Definition at line 59 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Constructor & Destructor Documentation

ComputeLinearFVGreenGaussGradientVolumeThread() [1/2]

ComputeLinearFVGreenGaussGradientVolumeThread::ComputeLinearFVGreenGaussGradientVolumeThread	(	FEProblemBase &	fe_problem,
		SystemBase &	system,
		std::vector< std::unique_ptr< NumericVector< Number >>> &	temporary_gradient
	)

Class constructor.

Parameters

fe_problem	Reference to the problem
system	The system which contains variables that need gradients.
temporary_gradient	Scratch storage holding the gradients being assembled.

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()),
    _temporary_gradient(temporary_gradient)
{
}

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 29 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),
    _temporary_gradient(x._temporary_gradient)
{
}

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

{
  ParallelUniqueId puid;
  _tid = puid.id;

  // Computing this size can be very expensive so we only want to do it once
  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())
    {
      if (!size)
        size = range.size();

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

      std::vector<std::vector<Real>> temporary_values(_temporary_gradient.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(_temporary_gradient))
          grad_reader.emplace_back(*_temporary_gradient[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(_temporary_gradient))
              temporary_values[dim_index][elem_i] =
                  grad_reader[dim_index](dof_indices[elem_i]) / 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");
              temporary_values[rz_radial_coord][elem_i] -=
                  _current_var->getElemValue(*elem_info, state) /
                  elem_info->centroid()(rz_radial_coord);
            }
          }
          elem_iterator++;
        }
      }
      for (const auto dim_index : index_range(_temporary_gradient))
      {
        _temporary_gradient[dim_index]->zero();
        _temporary_gradient[dim_index]->add_vector(temporary_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 88 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_dim

const unsigned int ComputeLinearFVGreenGaussGradientVolumeThread::_dim

protected

The dimension of the domain.

Definition at line 73 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

_fe_problem

FEProblemBase& ComputeLinearFVGreenGaussGradientVolumeThread::_fe_problem

protected

Definition at line 70 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_libmesh_system

const libMesh::System& ComputeLinearFVGreenGaussGradientVolumeThread::_libmesh_system

protected

Reference to the libmesh system.

Definition at line 79 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

_system

SystemBase& ComputeLinearFVGreenGaussGradientVolumeThread::_system

protected

The system wrapper this thread operates on.

Definition at line 76 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_system_number

const unsigned int ComputeLinearFVGreenGaussGradientVolumeThread::_system_number

protected

Global system number.

Definition at line 82 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_temporary_gradient

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

protected

Cache for the temporary gradient being built.

Definition at line 91 of file ComputeLinearFVGreenGaussGradientVolumeThread.h.

Referenced by operator()().

_tid

THREAD_ID ComputeLinearFVGreenGaussGradientVolumeThread::_tid

protected

Thread ID.

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