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, const unsigned int linear_system_num)
	Class constructor. More...
	ComputeLinearFVGreenGaussGradientFaceThread (ComputeLinearFVGreenGaussGradientFaceThread &x, Threads::split split)
	Splitting constructor. More...
void	operator() (const FaceInfoRange &range)
	Operator which is used to execute the thread over a certain iterator range. More...
void	join (const ComputeLinearFVGreenGaussGradientFaceThread &y)
	Join threads at the end of the execution. More...

Protected Attributes
FEProblemBase &	_fe_problem
	Reference to the problem. More...
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 (the number of this system in the libmesh equation system) More...
THREAD_ID	_tid
	Thread ID. More...
MooseLinearVariableFV< Real > *	_current_var
	Pointer to the current variable. More...
std::vector< std::unique_ptr< NumericVector< Number > > > &	_new_gradient
	Cache for the new gradient which is 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{S}_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 summation part over the faces ( u_f{S}_f).

Definition at line 34 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Member Typedef Documentation

FaceInfoRange

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

Definition at line 53 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Constructor & Destructor Documentation

ComputeLinearFVGreenGaussGradientFaceThread() [1/2]

ComputeLinearFVGreenGaussGradientFaceThread::ComputeLinearFVGreenGaussGradientFaceThread	(	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 ComputeLinearFVGreenGaussGradientFaceThread.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()),
    _new_gradient(_fe_problem.getLinearSystem(_linear_system_number).newGradientContainer())
{
}

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 28 of file ComputeLinearFVGreenGaussGradientFaceThread.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),
    // This will be the vector we work on since the old gradient might still be needed
    // to compute extrapolated boundary conditions for example.
    _new_gradient(x._new_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 156 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 42 of file ComputeLinearFVGreenGaussGradientFaceThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;

  unsigned int size = 0;

  for (const auto & variable :
       _fe_problem.getLinearSystem(_linear_system_number).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();

      std::vector<std::vector<Real>> new_values_elem(_new_gradient.size(),
                                                     std::vector<Real>(size, 0.0));
      std::vector<std::vector<Real>> new_values_neighbor(_new_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(*_linear_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))
            {
              new_values_elem[i][face_i] = contribution(i);
              new_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
                                                ? new_values_elem
                                                : new_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))
      {
        _new_gradient[i]->add_vector(new_values_elem[i].data(), dof_indices_elem);
        _new_gradient[i]->add_vector(new_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 83 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_dim

const unsigned int ComputeLinearFVGreenGaussGradientFaceThread::_dim

protected

The dimension of the domain.

Definition at line 68 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_fe_problem

FEProblemBase& ComputeLinearFVGreenGaussGradientFaceThread::_fe_problem

protected

Reference to the problem.

Definition at line 65 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_linear_system

const libMesh::LinearImplicitSystem& ComputeLinearFVGreenGaussGradientFaceThread::_linear_system

protected

Reference to the linear system at libmesh level.

Definition at line 74 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_linear_system_number

const unsigned int ComputeLinearFVGreenGaussGradientFaceThread::_linear_system_number

protected

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

Definition at line 71 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_new_gradient

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

protected

Cache for the new gradient which is being built.

It is needed because in certain scenarios the old gradient is used for computing the new gradient.

Definition at line 87 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 77 of file ComputeLinearFVGreenGaussGradientFaceThread.h.

Referenced by operator()().

_tid

THREAD_ID ComputeLinearFVGreenGaussGradientFaceThread::_tid

protected

Thread ID.

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