ComputeLinearFVGreenGaussGradientFaceThread 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 <ComputeLinearFVGreenGaussGradientFaceThread.h>

Public Types
using	FaceInfoRange = StoredRange< MooseMesh::const_face_info_iterator, const FaceInfo * >

Public Member Functions
	ComputeLinearFVGreenGaussGradientFaceThread (FEProblemBase &fe_problem, SystemBase &system, std::vector< std::unique_ptr< NumericVector< Number > > > &temporary_gradient)
	Class constructor.
	ComputeLinearFVGreenGaussGradientFaceThread (ComputeLinearFVGreenGaussGradientFaceThread &x, Threads::split split)
	Splitting constructor.
void	operator() (const FaceInfoRange &range)
	Operator which is used to execute the thread over a certain iterator range.
void	join (const ComputeLinearFVGreenGaussGradientFaceThread &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 (the number of this system in the libmesh equation system)
THREAD_ID	_tid
	Thread ID.
MooseLinearVariableFV< Real > *	_current_var
	Pointer to the current variable.
std::vector< std::unique_ptr< NumericVector< Number > > > &	_temporary_gradient
	Cache for the temporary gradient being built.

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{S}_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 summation part over the faces (\sum_f u_f\vec{S}_f).

Definition at line 35 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Member Typedef Documentation

FaceInfoRange

using ComputeLinearFVGreenGaussGradientFaceThread::FaceInfoRange = StoredRange<MooseMesh::const_face_info_iterator, const FaceInfo *>

Definition at line 56 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Constructor & Destructor Documentation

ComputeLinearFVGreenGaussGradientFaceThread() [1/2]

ComputeLinearFVGreenGaussGradientFaceThread::ComputeLinearFVGreenGaussGradientFaceThread	(	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 for gradients being assembled.

Definition at line 16 of file ComputeLinearFVGreenGaussGradientFaceThread.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)
{
}

ComputeLinearFVGreenGaussGradientFaceThread() [2/2]

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

Splitting constructor.

Parameters

x	Reference to the other bodies
split	The thread split

Definition at line 29 of file ComputeLinearFVGreenGaussGradientFaceThread.C.

  : _fe_problem(x._fe_problem),
    _dim(x._dim),
    _system(x._system),
    _libmesh_system(x._libmesh_system),
    _system_number(x._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.
    _temporary_gradient(x._temporary_gradient)
{
}

Member Function Documentation

join()

void ComputeLinearFVGreenGaussGradientFaceThread::join

(

const ComputeLinearFVGreenGaussGradientFaceThread &

y

)

Join threads at the end of the execution.

Parameters

y	Reference to the other bodies

Definition at line 157 of file ComputeLinearFVGreenGaussGradientFaceThread.C.

{
}

operator()()

void ComputeLinearFVGreenGaussGradientFaceThread::operator()

(

const FaceInfoRange &

range

)

Operator which is used to execute the thread over a certain iterator range.

Parameters

range

The range of FaceInfos which should be computed.

Definition at line 43 of file ComputeLinearFVGreenGaussGradientFaceThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;
 
  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();
 
      std::vector<std::vector<Real>> temporary_values_elem(_temporary_gradient.size(),
                                                           std::vector<Real>(size, 0.0));
      std::vector<std::vector<Real>> temporary_values_neighbor(_temporary_gradient.size(),
                                                               std::vector<Real>(size, 0.0));
      std::vector<dof_id_type> dof_indices_elem(size, 0);
      std::vector<dof_id_type> dof_indices_neighbor(size, 0);
 
      {
        PetscVectorReader solution_reader(*_libmesh_system.current_local_solution);
 
        // Iterate over all the face infos in the range
        auto face_iterator = range.begin();
        for (const auto & face_i : make_range(size))
        {
          const auto & face_info = *face_iterator;
 
          const auto current_face_type =
              face_info->faceType(std::make_pair(_current_var->number(), _system_number));
 
          // First we check if this face is internal to the variable, if yes, contribute to both
          // sides
          if (current_face_type == FaceInfo::VarFaceNeighbors::BOTH)
          {
            dof_indices_elem[face_i] =
                face_info->elemInfo()->dofIndices()[_system_number][_current_var->number()];
            dof_indices_neighbor[face_i] =
                face_info->neighborInfo()->dofIndices()[_system_number][_current_var->number()];
 
            const auto face_value =
                Moose::FV::linearInterpolation(solution_reader(dof_indices_elem[face_i]),
                                               solution_reader(dof_indices_neighbor[face_i]),
                                               *face_info,
                                               true);
 
            const auto contribution =
                face_info->normal() * face_info->faceArea() * face_info->faceCoord() * face_value;
 
            for (const auto i : make_range(_dim))
            {
              temporary_values_elem[i][face_i] = contribution(i);
              temporary_values_neighbor[i][face_i] = -contribution(i);
            }
          }
          // If this face is on the boundary of the block where the variable is defined, we
          // check for boundary conditions. If we don't find any we use an automatic one-term
          // expansion to compute the face value.
          else if (current_face_type == FaceInfo::VarFaceNeighbors::ELEM ||
                   current_face_type == FaceInfo::VarFaceNeighbors::NEIGHBOR)
          {
            auto * bc_pointer =
                _current_var->getBoundaryCondition(*face_info->boundaryIDs().begin());
 
            if (bc_pointer)
              bc_pointer->setupFaceData(face_info, current_face_type);
 
            const auto * const elem_info = current_face_type == FaceInfo::VarFaceNeighbors::ELEM
                                               ? face_info->elemInfo()
                                               : face_info->neighborInfo();
 
            // We have to account for cases when this face is an internal boundary and the normal
            // points in the wrong direction
            const auto multiplier =
                current_face_type == FaceInfo::VarFaceNeighbors::ELEM ? 1.0 : -1.0;
            auto & dof_id_container = current_face_type == FaceInfo::VarFaceNeighbors::ELEM
                                          ? dof_indices_elem
                                          : dof_indices_neighbor;
            auto & contribution_container = current_face_type == FaceInfo::VarFaceNeighbors::ELEM
                                                ? temporary_values_elem
                                                : temporary_values_neighbor;
 
            dof_id_container[face_i] =
                elem_info->dofIndices()[_system_number][_current_var->number()];
 
            // If we don't have a boundary condition, then it's a natural condition. We'll use a
            // one-term expansion approximation in that case
            const auto contribution = multiplier * face_info->normal() * face_info->faceArea() *
                                      face_info->faceCoord() *
                                      (bc_pointer ? bc_pointer->computeBoundaryValue()
                                                  : solution_reader(dof_id_container[face_i]));
            for (const auto i : make_range(_dim))
              contribution_container[i][face_i] = contribution(i);
          }
          face_iterator++;
        }
      }
      for (const auto i : make_range(_dim))
      {
        _temporary_gradient[i]->add_vector(temporary_values_elem[i].data(), dof_indices_elem);
        _temporary_gradient[i]->add_vector(temporary_values_neighbor[i].data(),
                                           dof_indices_neighbor);
      }
    }
  }
}

Member Data Documentation

_current_var

MooseLinearVariableFV<Real>* ComputeLinearFVGreenGaussGradientFaceThread::_current_var

protected

Pointer to the current variable.

Definition at line 86 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_dim

const unsigned int ComputeLinearFVGreenGaussGradientFaceThread::_dim

protected

The dimension of the domain.

Definition at line 71 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_fe_problem

FEProblemBase& ComputeLinearFVGreenGaussGradientFaceThread::_fe_problem

protected

Reference to the problem.

Definition at line 68 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

_libmesh_system

const libMesh::System& ComputeLinearFVGreenGaussGradientFaceThread::_libmesh_system

protected

Reference to the libMesh system backing the wrapper system.

Definition at line 77 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_system

SystemBase& ComputeLinearFVGreenGaussGradientFaceThread::_system

protected

The system wrapper this thread operates on.

Definition at line 74 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_system_number

const unsigned int ComputeLinearFVGreenGaussGradientFaceThread::_system_number

protected

Global system number (the number of this system in the libmesh equation system)

Definition at line 80 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_temporary_gradient

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

protected

Cache for the temporary gradient being built.

It is needed because in certain scenarios the old gradient is used while assembling the replacement gradient.

Definition at line 90 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_tid

THREAD_ID ComputeLinearFVGreenGaussGradientFaceThread::_tid

protected

Thread ID.

Definition at line 83 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

---

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

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