LinearFVGradientInterface Class Reference

Shared storage and allocation logic for linear finite-volume cell gradients for variables in the system attribute of this class. More...

#include <LinearFVGradientInterface.h>

Inheritance diagram for LinearFVGradientInterface:

Public Member Functions
	LinearFVGradientInterface (SystemBase &sys)
const std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > &	linearFVGradientContainer () const
	Access the stored raw cell-centered gradient components.
void	requestLinearFVLimitedGradients (const Moose::FV::GradientLimiterType limiter_type, unsigned int variable_number)
	Request storage and assembly of limiter-specific cell gradients.
const std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > &	linearFVLimitedGradientContainer (const Moose::FV::GradientLimiterType limiter_type) const
	Access the stored raw or limited cell-centered gradient components.
const std::unordered_set< Moose::FV::GradientLimiterType > &	requestedLinearFVLimitedGradientTypes () const
	Access the limiter types requested for this system.

Protected Member Functions
void	computeGradients ()
	Compute and store raw and requested limited Green-Gauss gradients for linear FV variables.
void	rebuildLinearFVGradientStorage ()
	Rebuild persistent raw and temporary gradient storage after mesh/DOF changes.
std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > &	temporaryLinearFVGradientContainer ()
	Return temporary storage for gradients during gradient assembly.
std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > &	temporaryLinearFVLimitedGradientContainer (const Moose::FV::GradientLimiterType limiter_type)
	Return temporary storage for limited gradients during gradient assembly.
std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > &	rawLinearFVLimitedGradientContainer (const Moose::FV::GradientLimiterType limiter_type)
	Access the persisted limited-gradient storage for a specific limiter.
const std::unordered_set< unsigned int > &	requestedLinearFVLimitedGradientVariables (const Moose::FV::GradientLimiterType limiter_type) const
	Access the variable numbers that requested limited gradients for a specific limiter.
bool	needsLinearFVGradientStorage () const
void	initializeContainer (std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > &container) const

Protected Attributes
SystemBase &	_sys
	Reference to the system object.
std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > >	_temporary_gradient
	Scratch storage for raw gradients assembled during the current compute pass.
std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > >	_raw_grad_container
	Persisted raw cell-centered gradient components keyed by spatial direction.
std::unordered_set< Moose::FV::GradientLimiterType >	_requested_limited_gradient_types
	Set of requested limiter types for which limited gradients should be computed.
std::unordered_map< Moose::FV::GradientLimiterType, std::unordered_set< unsigned int > >	_requested_limited_gradient_variables
	Variable numbers requesting limited gradients, keyed by limiter type.
std::unordered_map< Moose::FV::GradientLimiterType, std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > >	_raw_limited_grad_containers
	Persisted limited gradient components keyed by limiter type.
std::unordered_map< Moose::FV::GradientLimiterType, std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > >	_temporary_limited_gradient
	Scratch storage for limited gradients assembled during the current compute pass.

Detailed Description

Shared storage and allocation logic for linear finite-volume cell gradients for variables in the system attribute of this class.

Definition at line 35 of file LinearFVGradientInterface.h.

Constructor & Destructor Documentation

LinearFVGradientInterface()

LinearFVGradientInterface::LinearFVGradientInterface ( SystemBase &  sys )

inline

Definition at line 38 of file LinearFVGradientInterface.h.

: _sys(sys) {}

Member Function Documentation

computeGradients()

void LinearFVGradientInterface::computeGradients ( )

protected

Compute and store raw and requested limited Green-Gauss gradients for linear FV variables.

Definition at line 27 of file LinearFVGradientInterface.C.

{
  // No gradients have been requested, by now we should have set up the
  // containers to receive the gradients. Time to early return.
  if (_raw_grad_container.empty())
    return;
 
  auto & temporary_gradient = temporaryLinearFVGradientContainer();
  mooseAssert(temporary_gradient.size() == _raw_grad_container.size(),
              "Temporary and raw gradient containers must have the same size.");
  for (auto & vec : temporary_gradient)
    vec->zero();
 
  auto & fe_problem = _sys.feProblem();
  auto * const perf_graph_interface = dynamic_cast<PerfGraphInterface *>(&_sys);
  mooseAssert(perf_graph_interface,
              "LinearFVGradientInterface requires its owning system to implement "
              "PerfGraphInterface.");
  const auto perf_id = perf_graph_interface->registerTimedSection("LinearVariableFV_Gradients", 3);
  mooseAssert(!Threads::in_threads, "PerfGraph timing cannot be used within threaded sections");
  PerfGuard time_guard(perf_graph_interface->perfGraph(), perf_id);
 
  PARALLEL_TRY
  {
    using FaceInfoRange = StoredRange<MooseMesh::const_face_info_iterator, const FaceInfo *>;
    FaceInfoRange face_info_range(fe_problem.mesh().ownedFaceInfoBegin(),
                                  fe_problem.mesh().ownedFaceInfoEnd());
 
    ComputeLinearFVGreenGaussGradientFaceThread gradient_face_thread(
        fe_problem, _sys, temporary_gradient);
    Threads::parallel_reduce(face_info_range, gradient_face_thread);
  }
  fe_problem.checkExceptionAndStopSolve();
 
  for (auto & vec : temporary_gradient)
    vec->close();
 
  PARALLEL_TRY
  {
    using ElemInfoRange = StoredRange<MooseMesh::const_elem_info_iterator, const ElemInfo *>;
    ElemInfoRange elem_info_range(fe_problem.mesh().ownedElemInfoBegin(),
                                  fe_problem.mesh().ownedElemInfoEnd());
 
    ComputeLinearFVGreenGaussGradientVolumeThread gradient_volume_thread(
        fe_problem, _sys, temporary_gradient);
    Threads::parallel_reduce(elem_info_range, gradient_volume_thread);
  }
  fe_problem.checkExceptionAndStopSolve();
 
  for (const auto i : index_range(_raw_grad_container))
    temporary_gradient[i]->close();
 
  _raw_grad_container.swap(temporary_gradient);
 
  if (!requestedLinearFVLimitedGradientTypes().empty())
  {
    using ElemInfoRange = StoredRange<MooseMesh::const_elem_info_iterator, const ElemInfo *>;
    ElemInfoRange elem_info_range(fe_problem.mesh().ownedElemInfoBegin(),
                                  fe_problem.mesh().ownedElemInfoEnd());
 
    for (const auto limiter_type : requestedLinearFVLimitedGradientTypes())
    {
      if (limiter_type == Moose::FV::GradientLimiterType::None)
        continue;
 
      auto & raw_container = rawLinearFVLimitedGradientContainer(limiter_type);
      auto & temporary_container = temporaryLinearFVLimitedGradientContainer(limiter_type);
      mooseAssert(temporary_container.size() == raw_container.size(),
                  "Temporary and raw limited gradient containers must have the same size.");
      for (auto & vec : temporary_container)
        vec->zero();
 
      PARALLEL_TRY
      {
        ComputeLinearFVLimitedGradientThread limited_gradient_thread(
            fe_problem,
            _sys,
            _raw_grad_container,
            temporary_container,
            limiter_type,
            requestedLinearFVLimitedGradientVariables(limiter_type));
        Threads::parallel_reduce(elem_info_range, limited_gradient_thread);
      }
      fe_problem.checkExceptionAndStopSolve();
 
      for (auto & vec : temporary_container)
        vec->close();
 
      raw_container.swap(temporary_container);
    }
  }
}

Referenced by AuxiliarySystem::compute().

initializeContainer()

void LinearFVGradientInterface::initializeContainer ( std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > &  container ) const

protected

Definition at line 131 of file LinearFVGradientInterface.C.

{
  container.clear();
  mooseAssert(_sys.currentSolution(),
              "Current solution must exist before building FV gradient storage.");
  for (unsigned int i = 0; i < _sys.mesh().dimension(); ++i)
    container.push_back(_sys.currentSolution()->zero_clone());
}

Referenced by rebuildLinearFVGradientStorage(), and requestLinearFVLimitedGradients().

linearFVGradientContainer()

const std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > & LinearFVGradientInterface::linearFVGradientContainer ( ) const

inline

Access the stored raw cell-centered gradient components.

Returns

Raw cell-centered gradient vectors keyed by spatial direction.

Definition at line 45 of file LinearFVGradientInterface.h.

  {
    return _raw_grad_container;
  }

linearFVLimitedGradientContainer()

const std::vector< std::unique_ptr< NumericVector< Number > > > & LinearFVGradientInterface::linearFVLimitedGradientContainer

(

const Moose::FV::GradientLimiterType

limiter_type

)

const

Access the stored raw or limited cell-centered gradient components.

Parameters

limiter_type

The limiter type whose gradient container is being requested.

Returns

The requested raw or limited gradient vectors ordered by spatial direction.

Definition at line 198 of file LinearFVGradientInterface.C.

{
  if (limiter_type == Moose::FV::GradientLimiterType::None)
    return _raw_grad_container;
 
  const auto it = _raw_limited_grad_containers.find(limiter_type);
  if (it == _raw_limited_grad_containers.end())
    mooseError("Limited gradient container was requested but not initialized on system '",
               _sys.name(),
               "'.");
 
  return it->second;
}

needsLinearFVGradientStorage()

bool LinearFVGradientInterface::needsLinearFVGradientStorage ( ) const

protected

Definition at line 121 of file LinearFVGradientInterface.C.

{
  for (const auto * const field_var : _sys.variableWarehouse().fieldVariables())
    if (field_var->needsGradientVectorStorage())
      return true;
 
  return false;
}

Referenced by rebuildLinearFVGradientStorage().

rawLinearFVLimitedGradientContainer()

std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > & LinearFVGradientInterface::rawLinearFVLimitedGradientContainer ( const Moose::FV::GradientLimiterType  limiter_type )

inlineprotected

Access the persisted limited-gradient storage for a specific limiter.

Parameters

limiter_type

The limiter type whose persisted storage is being accessed.

Returns

The persisted limited-gradient vectors keyed by spatial direction.

Definition at line 117 of file LinearFVGradientInterface.h.

  {
    return _raw_limited_grad_containers[limiter_type];
  }

Referenced by LinearSystem::computeGradients().

rebuildLinearFVGradientStorage()

void LinearFVGradientInterface::rebuildLinearFVGradientStorage ( )

protected

Rebuild persistent raw and temporary gradient storage after mesh/DOF changes.

Definition at line 142 of file LinearFVGradientInterface.C.

{
  _raw_grad_container.clear();
  _temporary_gradient.clear();
  _raw_limited_grad_containers.clear();
  _temporary_limited_gradient.clear();
 
  if (!needsLinearFVGradientStorage())
    return;
 
  initializeContainer(_raw_grad_container);
  initializeContainer(_temporary_gradient);
 
  for (const auto limiter_type : _requested_limited_gradient_types)
  {
    if (limiter_type == Moose::FV::GradientLimiterType::None)
      continue;
 
    initializeContainer(_raw_limited_grad_containers[limiter_type]);
    initializeContainer(_temporary_limited_gradient[limiter_type]);
  }
}

Referenced by AuxiliarySystem::AuxiliarySystem(), LinearSystem::initialSetup(), AuxiliarySystem::reinit(), and LinearSystem::reinit().

requestedLinearFVLimitedGradientTypes()

const std::unordered_set< Moose::FV::GradientLimiterType > & LinearFVGradientInterface::requestedLinearFVLimitedGradientTypes ( ) const

inline

Access the limiter types requested for this system.

Returns

The set of limiter types whose limited gradients should be assembled. They are only assembled for the variable(s) for which they were requested not all of them

Definition at line 72 of file LinearFVGradientInterface.h.

  {
    return _requested_limited_gradient_types;
  }

Referenced by LinearSystem::computeGradients().

requestedLinearFVLimitedGradientVariables()

const std::unordered_set< unsigned int > & LinearFVGradientInterface::requestedLinearFVLimitedGradientVariables ( const Moose::FV::GradientLimiterType  limiter_type ) const

inlineprotected

Access the variable numbers that requested limited gradients for a specific limiter.

Parameters

limiter_type

The limiter type whose request set is being accessed.

Returns

The set of variable numbers that requested the limiter.

Definition at line 128 of file LinearFVGradientInterface.h.

  {
    return libmesh_map_find(_requested_limited_gradient_variables, limiter_type);
  }

Referenced by LinearSystem::computeGradients().

requestLinearFVLimitedGradients()

void LinearFVGradientInterface::requestLinearFVLimitedGradients	(	const Moose::FV::GradientLimiterType	limiter_type,
		unsigned int	variable_number
	)

Request storage and assembly of limiter-specific cell gradients.

Parameters

limiter_type	The limiter whose gradient storage should be made available.
variable_number	The libMesh variable number requesting the limited gradients.

Definition at line 166 of file LinearFVGradientInterface.C.

{
  if (limiter_type == Moose::FV::GradientLimiterType::None)
    return;
 
  auto * const variable =
      dynamic_cast<MooseVariableFieldBase *>(_sys.variableWarehouse().getVariable(variable_number));
  if (!variable)
    mooseError("Limited gradients were requested for variable number ",
               variable_number,
               " on system '",
               _sys.name(),
               "', but no field variable with that number exists on the system.");
 
  if (!variable->needsGradientVectorStorage())
    mooseError("Limited gradients were requested for variable '",
               variable->name(),
               "' on system '",
               _sys.name(),
               "', but regular gradients were not requested for that variable.");
 
  _requested_limited_gradient_variables[limiter_type].insert(variable_number);
 
  if (_requested_limited_gradient_types.insert(limiter_type).second && !_raw_grad_container.empty())
  {
    initializeContainer(_raw_limited_grad_containers[limiter_type]);
    initializeContainer(_temporary_limited_gradient[limiter_type]);
  }
}

temporaryLinearFVGradientContainer()

std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > & LinearFVGradientInterface::temporaryLinearFVGradientContainer ( )

inlineprotected

Return temporary storage for gradients during gradient assembly.

The returned vectors are persistent scratch storage reused across calls and swapped with the final gradient container before gradient assembly returns.

Definition at line 94 of file LinearFVGradientInterface.h.

  {
    return _temporary_gradient;
  }

Referenced by computeGradients().

temporaryLinearFVLimitedGradientContainer()

std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > > & LinearFVGradientInterface::temporaryLinearFVLimitedGradientContainer ( const Moose::FV::GradientLimiterType  limiter_type )

inlineprotected

Return temporary storage for limited gradients during gradient assembly.

The returned vectors are persistent scratch storage reused across calls and swapped with the final limited-gradient container before gradient assembly returns.

Parameters

limiter_type

The limiter type whose temporary storage is being accessed.

Definition at line 106 of file LinearFVGradientInterface.h.

  {
    return _temporary_limited_gradient[limiter_type];
  }

Referenced by LinearSystem::computeGradients().

Member Data Documentation

_raw_grad_container

std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number> > > LinearFVGradientInterface::_raw_grad_container

protected

Persisted raw cell-centered gradient components keyed by spatial direction.

Definition at line 145 of file LinearFVGradientInterface.h.

Referenced by AuxiliarySystem::compute(), computeGradients(), LinearSystem::computeGradients(), linearFVGradientContainer(), linearFVLimitedGradientContainer(), rebuildLinearFVGradientStorage(), and requestLinearFVLimitedGradients().

_raw_limited_grad_containers

std::unordered_map<Moose::FV::GradientLimiterType, std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number> > > > LinearFVGradientInterface::_raw_limited_grad_containers

protected

Persisted limited gradient components keyed by limiter type.

Definition at line 157 of file LinearFVGradientInterface.h.

Referenced by linearFVLimitedGradientContainer(), rawLinearFVLimitedGradientContainer(), rebuildLinearFVGradientStorage(), and requestLinearFVLimitedGradients().

_requested_limited_gradient_types

std::unordered_set<Moose::FV::GradientLimiterType> LinearFVGradientInterface::_requested_limited_gradient_types

protected

Set of requested limiter types for which limited gradients should be computed.

Definition at line 148 of file LinearFVGradientInterface.h.

Referenced by rebuildLinearFVGradientStorage(), requestedLinearFVLimitedGradientTypes(), and requestLinearFVLimitedGradients().

_requested_limited_gradient_variables

std::unordered_map<Moose::FV::GradientLimiterType, std::unordered_set<unsigned int> > LinearFVGradientInterface::_requested_limited_gradient_variables

protected

Variable numbers requesting limited gradients, keyed by limiter type.

Definition at line 152 of file LinearFVGradientInterface.h.

Referenced by requestedLinearFVLimitedGradientVariables(), and requestLinearFVLimitedGradients().

_sys

SystemBase& LinearFVGradientInterface::_sys

protected

Reference to the system object.

Definition at line 139 of file LinearFVGradientInterface.h.

Referenced by computeGradients(), LinearSystem::computeGradients(), initializeContainer(), AuxiliarySystem::linearFVLimitedGradientContainer(), linearFVLimitedGradientContainer(), needsLinearFVGradientStorage(), and requestLinearFVLimitedGradients().

_temporary_gradient

std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number> > > LinearFVGradientInterface::_temporary_gradient

protected

Scratch storage for raw gradients assembled during the current compute pass.

Definition at line 142 of file LinearFVGradientInterface.h.

Referenced by rebuildLinearFVGradientStorage(), and temporaryLinearFVGradientContainer().

_temporary_limited_gradient

std::unordered_map<Moose::FV::GradientLimiterType, std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number> > > > LinearFVGradientInterface::_temporary_limited_gradient

protected

Scratch storage for limited gradients assembled during the current compute pass.

Definition at line 162 of file LinearFVGradientInterface.h.

Referenced by rebuildLinearFVGradientStorage(), requestLinearFVLimitedGradients(), and temporaryLinearFVLimitedGradientContainer().

---

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

• include/systems/LinearFVGradientInterface.h
• src/systems/LinearFVGradientInterface.C