LinearFVGradientInterface Class Reference

Registration, update, and allocation logic for linear finite-volume cell gradients. More...

#include <LinearFVGradientInterface.h>

Inheritance diagram for LinearFVGradientInterface:

Classes
struct	LinearFVGradientContainer
	Gradient values for all variables using the same gradient method. More...

Public Member Functions
	LinearFVGradientInterface (SystemBase &sys)
const FVGradientMethod &	resolveFVGradientMethod (const GradientMethodName &method_name)
	Resolve a named gradient method, constructing a built-in method when needed.
LinearFVGradientReader	registerFVGradient (unsigned int variable_number, const FVGradientMethod &method)
	Register a variable for gradient values produced by a method object.

Protected Types
using	GradientContainer = LinearFVGradientReader::GradientContainer
	One vector per spatial component of a cell-centered gradient field.

Protected Member Functions
void	computeGradients ()
	Compute and finalize all registered linear FV gradient fields.
void	updateFVGradient (const LinearFVGradientReader &reader)
	Update a registered gradient reader explicitly.
void	rebuildLinearFVGradientStorage ()
	Rebuild cached gradient values and reusable scratch storage after mesh/DOF changes.
bool	hasLinearFVGradients () const
	Whether any linear finite-volume gradient fields have been registered to this object.
void	initializeContainer (GradientContainer &container) const
	Allocate one zeroed vector per spatial component for gradient storage.
LinearFVGradientContainer &	computeLinearFVGradientContainer (const FVGradientMethod &method)
	Compute replacement field values for a registered gradient method.
void	finalizeLinearFVGradientContainer (LinearFVGradientContainer &container)
	Replace the current gradient storage with the freshly computed new gradients.

Protected Attributes
SystemBase &	_sys
	Reference to the system object.
std::unordered_map< const FVGradientMethod *, LinearFVGradientContainer >	_linear_fv_gradient_container_by_method
	Gradient containers keyed by the method object that produces them.

Detailed Description

Registration, update, and allocation logic for linear finite-volume cell gradients.

This interface should be inherited by system classes that may own linear finite-volume variables

Definition at line 38 of file LinearFVGradientInterface.h.

Member Typedef Documentation

GradientContainer

using LinearFVGradientInterface::GradientContainer = LinearFVGradientReader::GradientContainer

protected

One vector per spatial component of a cell-centered gradient field.

Definition at line 63 of file LinearFVGradientInterface.h.

Constructor & Destructor Documentation

LinearFVGradientInterface()

LinearFVGradientInterface::LinearFVGradientInterface ( SystemBase &  sys )

inline

Parameters

sys	System that owns registered linear finite-volume gradient fields.

Definition at line 44 of file LinearFVGradientInterface.h.

: _sys(sys) {}

Member Function Documentation

computeGradients()

void LinearFVGradientInterface::computeGradients ( )

protected

Compute and finalize all registered linear FV gradient fields.

Definition at line 77 of file LinearFVGradientInterface.C.

{
  if (_linear_fv_gradient_container_by_method.empty())
    return;
 
  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);
 
  // Keep current values unchanged until every replacement has been computed so boundary
  // conditions consistently use gradients from the previous update.
  // BCs may use cell gradients to compute the boundary face value, which is itself used to
  // compute cell gradients
  for (auto & method_container_pair : _linear_fv_gradient_container_by_method)
    computeLinearFVGradientContainer(*method_container_pair.first);
 
  for (auto & method_container_pair : _linear_fv_gradient_container_by_method)
    finalizeLinearFVGradientContainer(method_container_pair.second);
}

Referenced by AuxiliarySystem::compute().

computeLinearFVGradientContainer()

LinearFVGradientInterface::LinearFVGradientContainer & LinearFVGradientInterface::computeLinearFVGradientContainer ( const FVGradientMethod &  method )

protected

Compute replacement field values for a registered gradient method.

Parameters

method

Gradient method used to compute the replacement values.

Returns

Method container whose replacement values were computed.

Definition at line 148 of file LinearFVGradientInterface.C.

{
  auto & container = libmesh_map_find(_linear_fv_gradient_container_by_method, &method);
 
  mooseAssert(!container.values.empty(),
              "Gradient storage must be initialized before gradient computation.");
  mooseAssert(!container.next_values.empty(),
              "Replacement gradient storage must be initialized before gradient computation.");
  mooseAssert(container.next_values.size() == container.values.size(),
              "Next and current gradient containers must have the same size.");
 
  method.computeGradient(_sys, container.next_values, container.variable_numbers);
 
  return container;
}

Referenced by computeGradients(), and updateFVGradient().

finalizeLinearFVGradientContainer()

void LinearFVGradientInterface::finalizeLinearFVGradientContainer ( LinearFVGradientContainer &  container )

protected

Replace the current gradient storage with the freshly computed new gradients.

Parameters

container

Method container whose gradient values should be finalized.

Definition at line 165 of file LinearFVGradientInterface.C.

{
  mooseAssert(container.next_values.size() == container.values.size(),
              "Next and current gradient containers must have the same size.");
  container.values.swap(container.next_values);
}

Referenced by computeGradients(), and updateFVGradient().

hasLinearFVGradients()

bool LinearFVGradientInterface::hasLinearFVGradients ( ) const

protected

Whether any linear finite-volume gradient fields have been registered to this object.

Definition at line 132 of file LinearFVGradientInterface.C.

{
  return !_linear_fv_gradient_container_by_method.empty();
}

Referenced by AuxiliarySystem::compute(), and rebuildLinearFVGradientStorage().

initializeContainer()

void LinearFVGradientInterface::initializeContainer ( GradientContainer &  container ) const

protected

Allocate one zeroed vector per spatial component for gradient storage.

Parameters

container

Component-vector container to rebuild.

Definition at line 138 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().

rebuildLinearFVGradientStorage()

void LinearFVGradientInterface::rebuildLinearFVGradientStorage ( )

protected

Rebuild cached gradient values and reusable scratch storage after mesh/DOF changes.

Definition at line 173 of file LinearFVGradientInterface.C.

{
  for (auto & method_container_pair : _linear_fv_gradient_container_by_method)
  {
    method_container_pair.second.values.clear();
    method_container_pair.second.next_values.clear();
  }
 
  if (!hasLinearFVGradients())
    return;
 
  for (auto & method_container_pair : _linear_fv_gradient_container_by_method)
  {
    initializeContainer(method_container_pair.second.values);
    initializeContainer(method_container_pair.second.next_values);
  }
}

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

registerFVGradient()

LinearFVGradientReader LinearFVGradientInterface::registerFVGradient	(	unsigned int	variable_number,
		const FVGradientMethod &	method
	)

Register a variable for gradient values produced by a method object.

Parameters

variable_number	Variable number whose gradient should be stored.
method	Gradient method that computes the field values.

Definition at line 52 of file LinearFVGradientInterface.C.

{
  auto * const variable =
      dynamic_cast<MooseVariableFieldBase *>(_sys.variableWarehouse().getVariable(variable_number));
  if (!variable)
    mooseError("Linear FV gradients were requested for variable number ",
               variable_number,
               " on system '",
               _sys.name(),
               "', but no field variable with that number exists on the system.");
 
  auto & container = _linear_fv_gradient_container_by_method[&method];
  container.variable_numbers.insert(variable_number);
 
  if (container.values.empty() && _sys.currentSolution())
    initializeContainer(container.values);
 
  if (container.next_values.empty() && _sys.currentSolution())
    initializeContainer(container.next_values);
 
  return LinearFVGradientReader(_sys, container.values, method, variable_number);
}

resolveFVGradientMethod()

const FVGradientMethod & LinearFVGradientInterface::resolveFVGradientMethod

(

const GradientMethodName &

method_name

)

Resolve a named gradient method, constructing a built-in method when needed.

Parameters

method_name

Name of the gradient method to retrieve.

Returns

Gradient method associated with the supplied name.

Definition at line 26 of file LinearFVGradientInterface.C.

{
  auto & fe_problem = _sys.feProblem();
 
  if (!fe_problem.hasFVGradientMethod(method_name))
  {
    if (method_name == "green-gauss")
    {
      auto params = fe_problem.getMooseApp().getFactory().getValidParams("FVGreenGaussGradient");
      fe_problem.addFVGradientMethod("FVGreenGaussGradient", method_name, params);
    }
    else if (method_name == "green-gauss-venkatakrishnan")
    {
      auto params = fe_problem.getMooseApp().getFactory().getValidParams("FVGreenGaussGradient");
      params.set<MooseEnum>("limiter") = "venkatakrishnan";
      fe_problem.addFVGradientMethod("FVGreenGaussGradient", method_name, params);
    }
  }
 
  if (!fe_problem.hasFVGradientMethod(method_name))
    mooseError("Unable to find FVGradientMethod with name '", method_name, "'");
 
  return fe_problem.getFVGradientMethod(method_name);
}

updateFVGradient()

void LinearFVGradientInterface::updateFVGradient ( const LinearFVGradientReader &  reader )

protected

Update a registered gradient reader explicitly.

Parameters

reader

Gradient reader to update.

Definition at line 102 of file LinearFVGradientInterface.C.

{
  if (&reader.system() != &_sys)
    mooseError("Requested update for a linear FV gradient field from a different system than '",
               _sys.name(),
               "'.");
 
  const auto method_container_pair = _linear_fv_gradient_container_by_method.find(&reader.method());
  if (method_container_pair != _linear_fv_gradient_container_by_method.end())
  {
    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);
 
    auto & container = computeLinearFVGradientContainer(reader.method());
    finalizeLinearFVGradientContainer(container);
    return;
  }
 
  mooseError("Requested update for an unregistered linear FV gradient field on system '",
             _sys.name(),
             "'.");
}

Member Data Documentation

_linear_fv_gradient_container_by_method

std::unordered_map<const FVGradientMethod *, LinearFVGradientContainer> LinearFVGradientInterface::_linear_fv_gradient_container_by_method

protected

Gradient containers keyed by the method object that produces them.

Definition at line 119 of file LinearFVGradientInterface.h.

Referenced by computeGradients(), computeLinearFVGradientContainer(), hasLinearFVGradients(), rebuildLinearFVGradientStorage(), and updateFVGradient().

_sys

SystemBase& LinearFVGradientInterface::_sys

protected

Reference to the system object.

Definition at line 115 of file LinearFVGradientInterface.h.

Referenced by computeGradients(), computeLinearFVGradientContainer(), initializeContainer(), registerFVGradient(), resolveFVGradientMethod(), and updateFVGradient().

---

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

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