Implements all the methods for assembling a hybridized local discontinuous Galerkin (LDG-H), which is a type of HDG method, discretization of the diffusion equation. More...

#include <DiffusionLHDGAssemblyHelper.h>

Inheritance diagram for DiffusionLHDGAssemblyHelper:

[legend]

Public Member Functions
	DiffusionLHDGAssemblyHelper (const MooseObject const moose_obj, MaterialPropertyInterface const mpi, MooseVariableDependencyInterface const mvdi, const TransientInterface const ti, const FEProblemBase &fe_problem, SystemBase &sys, const THREAD_ID tid)

void	checkCoupling ()

template<>
const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

template<>
const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

Static Public Member Functions
static InputParameters	validParams ()

static std::string	deduceFunctorName (const std::string &name, const InputParameters &params)
	Helper to look up a functor name through the input parameter keys.

Protected Member Functions
void	vectorVolumeResidual (const MooseArray< Gradient > &vector_sol, const MooseArray< Number > &scalar_sol, const MooseArray< Real > &JxW, const libMesh::QBase &qrule, DenseVector< Number > &vector_re)
	Computes a local residual vector for the weak form: (q, v) + (u, div(v)) where q is the vector field representing the gradient of u, v are its associated test functions, and u is the diffused scalar field.

void	vectorVolumeJacobian (const MooseArray< Real > &JxW, const libMesh::QBase &qrule, DenseMatrix< Number > &vector_vector_jac, DenseMatrix< Number > &vector_scalar_jac)
	Computes a local Jacobian matrix for the weak form: (q, v) + (u, div(v)) where q is the vector field representing the gradient, v are its associated test functions, and u is the scalar field.

void	scalarVolumeResidual (const MooseArray< Gradient > &vector_field, const Moose::Functor< Real > &source, const MooseArray< Real > &JxW, const libMesh::QBase &qrule, const Elem *const current_elem, const MooseArray< Point > &q_point, DenseVector< Number > &scalar_re)
	Computes a local residual vector for the weak form: (Dq, grad(w)) - (f, w) where D is the diffusivity, w are the test functions associated with the scalar field, and f is a forcing function.

void	scalarVolumeJacobian (const MooseArray< Real > &JxW, const libMesh::QBase &qrule, DenseMatrix< Number > &scalar_vector_jac)
	Computes a local Jacobian matrix for the weak form: (Dq, grad(w)) - (f, w) where D is the diffusivity, w are the test functions associated with the scalar field, and f is a forcing function.

void	vectorFaceResidual (const MooseArray< Number > &lm_sol, const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseVector< Number > &vector_re)
	Computes a local residual vector for the weak form: -<\hat{u}, n*v> where \hat{u} is the trace of the scalar field, n is the normal vector, and v are the test functions associated with the gradient field.

void	vectorFaceJacobian (const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseMatrix< Number > &vector_lm_jac)
	Computes a local Jacobian matrix for the weak form: -<\hat{u}, n*v> where \hat{u} is the trace of the scalar field, n is the normal vector, and v are the test functions associated with the gradient field.

void	scalarFaceResidual (const MooseArray< Gradient > &vector_sol, const MooseArray< Number > &scalar_sol, const MooseArray< Number > &lm_sol, const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseVector< Number > &scalar_re)
	Computes a local residual vector for the weak form: -<Dqn, w> + <\tau (u - \hat{u}) * n * n, w>

void	scalarFaceJacobian (const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseMatrix< Number > &scalar_vector_jac, DenseMatrix< Number > &scalar_scalar_jac, DenseMatrix< Number > &scalar_lm_jac)
	Computes a local Jacobian matrix for the weak form: -<Dqn, w> + <\tau (u - \hat{u}) * n * n, w>

void	lmFaceResidual (const MooseArray< Gradient > &vector_sol, const MooseArray< Number > &scalar_sol, const MooseArray< Number > &lm_sol, const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseVector< Number > &lm_re)
	Computes a local residual vector for the weak form: -<Dqn, \mu> + <\tau (u - \hat{u}) * n * n, \mu>

void	lmFaceJacobian (const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseMatrix< Number > &lm_vec_jac, DenseMatrix< Number > &lm_scalar_jac, DenseMatrix< Number > &lm_lm_jac)
	Computes a local Jacobian matrix for the weak form: -<Dqn, \mu> + <\tau (u - \hat{u}) * n * n, \mu>

void	vectorDirichletResidual (const Moose::Functor< Real > &dirichlet_value, const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, const Elem *const current_elem, const unsigned int current_side, const MooseArray< Point > &q_point_face, DenseVector< Number > &vector_re)
	Weakly imposes a Dirichlet condition for the scalar field in the vector (gradient) equation.

void	scalarDirichletResidual (const MooseArray< Gradient > &vector_sol, const MooseArray< Number > &scalar_sol, const Moose::Functor< Real > &dirichlet_value, const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, const Elem *const current_elem, const unsigned int current_side, const MooseArray< Point > &q_point_face, DenseVector< Number > &scalar_re)
	Weakly imposes a Dirichlet condition for the scalar field in the scalar field equation.

void	scalarDirichletJacobian (const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseMatrix< Number > &scalar_vector_jac, DenseMatrix< Number > &scalar_scalar_jac)
	Computes the Jacobian for a Dirichlet condition for the scalar field in the scalar field equation.

void	createIdentityResidual (const MooseArray< Real > &JxW, const libMesh::QBase &qrule, const MooseArray< std::vector< Real > > &phi, const MooseArray< Number > &sol, DenseVector< Number > &re)
	Creates residuals corresponding to the weak form (v, \hat{u}), or stated simply this routine can be used to drive Lagrange multiplier values on the boundary to zero.

void	createIdentityJacobian (const MooseArray< Real > &JxW, const libMesh::QBase &qrule, const MooseArray< std::vector< Real > > &phi, DenseMatrix< Number > &ke)
	As above, but for the Jacobians.

std::string	deduceFunctorName (const std::string &name) const
	Small helper to look up a functor name through the input parameter keys.

template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name)
	Retrieves a functor from the subproblem.

template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, THREAD_ID tid)
	Retrieves a functor from the subproblem.

template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem)
	Retrieves a functor from the passed-in subproblem.

template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem, THREAD_ID tid)
	Retrieves a functor from the passed-in subproblem.

bool	isFunctor (const std::string &name) const
	Checks the subproblem for the given functor.

bool	isFunctor (const std::string &name, const SubProblem &subproblem) const
	Checks the passed-in subproblem for the given functor.

Moose::ElemArg	makeElemArg (const Elem *elem, bool correct_skewnewss=false) const
	Helper method to create an elemental argument for a functor that includes whether to perform skewness corrections.

template<typename T >
void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)
	Throws error if the functor does not support the requested side integration.

template<typename T >
const Moose::Functor< T > &	getFunctorByName (const std::string &name)
	Retrieves a functor from the subproblem.

Protected Attributes
const MooseVariableFE< Real > &	_u_var

const MooseVariableFE< RealVectorValue > &	_grad_u_var

const MooseVariableFE< Real > &	_u_face_var

const std::vector< dof_id_type > &	_qu_dof_indices

const std::vector< dof_id_type > &	_u_dof_indices

const std::vector< dof_id_type > &	_lm_u_dof_indices

const MooseArray< libMesh::Gradient > &	_qu_sol

const MooseArray< Number > &	_u_sol

const MooseArray< Number > &	_lm_u_sol

const MooseArray< std::vector< RealVectorValue > > &	_vector_phi

const MooseArray< std::vector< Real > > &	_scalar_phi

const MooseArray< std::vector< RealVectorValue > > &	_grad_scalar_phi

const MooseArray< std::vector< Real > > &	_div_vector_phi

const MooseArray< std::vector< RealVectorValue > > &	_vector_phi_face

const MooseArray< std::vector< Real > > &	_scalar_phi_face

const MooseArray< std::vector< Real > > &	_lm_phi_face

const MaterialProperty< Real > &	_diff
	The diffusivity.

const TransientInterface &	_ti
	Reference to transient interface.

const Real	_tau
	Our stabilization coefficient.

const Elem *	_cached_elem
	A data member used for determining when to compute the Jacobian.

DenseVector< Number >	_vector_re

DenseVector< Number >	_scalar_re

DenseVector< Number >	_lm_re

DenseMatrix< Number >	_vector_vector_jac

DenseMatrix< Number >	_vector_scalar_jac

DenseMatrix< Number >	_scalar_vector_jac

DenseMatrix< Number >	_scalar_scalar_jac

DenseMatrix< Number >	_scalar_lm_jac

DenseMatrix< Number >	_lm_scalar_jac

DenseMatrix< Number >	_lm_lm_jac

DenseMatrix< Number >	_vector_lm_jac

DenseMatrix< Number >	_lm_vector_jac

Private Member Functions
virtual bool	isADObject () const override
	Whether this interface is for an AD object.

template<typename T >
const Moose::Functor< T > &	getFunctorByName (const std::string &name, SubProblem &subproblem, THREAD_ID tid)
	Retrieves a functor from the passed-in subproblem.

template<typename T >
const Moose::Functor< T > *	defaultFunctor (const std::string &name)
	Helper function to parse default functor values.

template<>
const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

template<>
const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

Private Attributes
const MooseObject &	_moose_obj
	A reference to our associated MooseObject for error reporting.

const FEProblemBase &	_dhah_fe_problem
	A reference to the finite element problem used for coupling checks.

const SystemBase &	_dhah_sys
	A reference to the nonlinear system used for coupling checks.

const InputParameters &	_fi_params
	Parameters of the object with this interface.

const std::string	_fi_name
	The name of the object that this interface belongs to.

SubProblem *const	_fi_subproblem
	Pointer to subproblem if the subproblem pointer parameter was set.

const THREAD_ID	_fi_tid
	Current threaded it.

std::vector< std::unique_ptr< Moose::Functor< Real > > >	_default_real_functors
	Storage vector for Moose::Functor<Real> default objects.

std::vector< std::unique_ptr< Moose::Functor< ADReal > > >	_default_ad_real_functors
	Storage vector for Moose::Functor<ADReal> default objects.

Detailed Description

Implements all the methods for assembling a hybridized local discontinuous Galerkin (LDG-H), which is a type of HDG method, discretization of the diffusion equation.

These routines may be called by both HDG kernels and integrated boundary conditions. The implementation here is based (but not exactly based) on "A superconvergent LDG-hybridizable Galerkin method for second-order elliptic problems" by Cockburn

Definition at line 40 of file DiffusionLHDGAssemblyHelper.h.

Constructor & Destructor Documentation

◆ DiffusionLHDGAssemblyHelper()

DiffusionLHDGAssemblyHelper::DiffusionLHDGAssemblyHelper	(	const MooseObject *const	moose_obj,
		MaterialPropertyInterface *const	mpi,
		MooseVariableDependencyInterface *const	mvdi,
		const TransientInterface *const	ti,
		const FEProblemBase &	fe_problem,
		SystemBase &	sys,
		const THREAD_ID	tid
	)

Definition at line 37 of file DiffusionLHDGAssemblyHelper.C.

  : ADFunctorInterface(moose_obj),
    _u_var(sys.getFieldVariable<Real>(tid, moose_obj->getParam<NonlinearVariableName>("variable"))),
    _grad_u_var(sys.getFieldVariable<RealVectorValue>(
        tid, moose_obj->getParam<NonlinearVariableName>("gradient_variable"))),
    _u_face_var(sys.getFieldVariable<Real>(
        tid, moose_obj->getParam<NonlinearVariableName>("face_variable"))),
    _qu_dof_indices(_grad_u_var.dofIndices()),
    _u_dof_indices(_u_var.dofIndices()),
    _lm_u_dof_indices(_u_face_var.dofIndices()),
    _qu_sol(_grad_u_var.sln()),
    _u_sol(_u_var.sln()),
    _lm_u_sol(_u_face_var.sln()),
    _vector_phi(_grad_u_var.phi()),
    _scalar_phi(_u_var.phi()),
    _grad_scalar_phi(_u_var.gradPhi()),
    _div_vector_phi(_grad_u_var.divPhi()),
    _vector_phi_face(_grad_u_var.phiFace()),
    _scalar_phi_face(_u_var.phiFace()),
    _lm_phi_face(_u_face_var.phiFace()),
    _diff(mpi->getMaterialProperty<Real>("diffusivity")),
    _ti(*ti),
    _tau(moose_obj->getParam<Real>("tau")),
    _cached_elem(nullptr),
    _moose_obj(*moose_obj),
    _dhah_fe_problem(fe_problem),
    _dhah_sys(sys)
{
  mvdi->addMooseVariableDependency(&const_cast<MooseVariableFE<RealVectorValue> &>(_grad_u_var));
  mvdi->addMooseVariableDependency(&const_cast<MooseVariableFE<Real> &>(_u_face_var));
}

Member Function Documentation

◆ checkCoupling()

void DiffusionLHDGAssemblyHelper::checkCoupling ( )

Definition at line 77 of file DiffusionLHDGAssemblyHelper.C.

{
  // This check must occur after FEProblemBase::init()
  if (_dhah_fe_problem.coupling() == Moose::COUPLING_FULL)
    return;
  else if (_dhah_fe_problem.coupling() == Moose::COUPLING_CUSTOM)
  {
    const auto * const cm = _dhah_fe_problem.couplingMatrix(_dhah_sys.number());
    for (const auto i : make_range(cm->size()))
      for (const auto j : make_range(cm->size()))
        if ((*cm)(i, j) != true)
          goto error;
 
    return;
  }
 
error:
  _moose_obj.mooseError(
      "This class encodes the full Jacobian regardless of user input file specification, "
      "so please request full coupling for system ",
      _dhah_sys.name(),
      "  in your Preconditioning block for consistency");
}

Referenced by DiffusionLHDGDirichletBC::initialSetup(), DiffusionLHDGPrescribedGradientBC::initialSetup(), and DiffusionLHDGKernel::initialSetup().

◆ checkFunctorSupportsSideIntegration()

template<typename T >

void FunctorInterface::checkFunctorSupportsSideIntegration	(	const std::string &	name,
		bool	qp_integration
	)

protectedinherited

Throws error if the functor does not support the requested side integration.

Parameters

[in]	name	Name of functor or functor parameter
[in]	qp_integration	True if performing qp integration, false if face info

Definition at line 261 of file FunctorInterface.h.

{
  const std::string functor_name = deduceFunctorName(name);
  const auto & functor = getFunctor<T>(name);
  if (qp_integration)
  {
    if (!functor.supportsElemSideQpArg())
      mooseError("Quadrature point integration was requested, but the functor '",
                 functor_name,
                 "' does not support this.");
  }
  else
  {
    if (!functor.supportsFaceArg())
      mooseError("Face info integration was requested, but the functor '",
                 functor_name,
                 "' does not support this.");
  }
}

◆ createIdentityJacobian()

void DiffusionLHDGAssemblyHelper::createIdentityJacobian	(	const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		const MooseArray< std::vector< Real > > &	phi,
		DenseMatrix< Number > &	ke
	)

protected

As above, but for the Jacobians.

Definition at line 418 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule.n_points()))
    for (const auto i : index_range(phi))
    {
      const auto qpi_term = JxW[qp] * phi[i][qp];
      for (const auto j : index_range(phi))
        ke(i, j) -= phi[j][qp] * qpi_term;
    }
}

Referenced by DiffusionLHDGDirichletBC::computeJacobian().

◆ createIdentityResidual()

void DiffusionLHDGAssemblyHelper::createIdentityResidual	(	const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		const MooseArray< std::vector< Real > > &	phi,
		const MooseArray< Number > &	sol,
		DenseVector< Number > &	re
	)

protected

Creates residuals corresponding to the weak form (v, \hat{u}), or stated simply this routine can be used to drive Lagrange multiplier values on the boundary to zero.

This should be used on boundaries where there are Dirichlet conditions for the primal variables such that there is no need for the Lagrange multiplier variables

Definition at line 403 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule.n_points()))
  {
    const auto qp_term = JxW[qp] * sol[qp];
    for (const auto i : index_range(phi))
      re(i) -= phi[i][qp] * qp_term;
  }
}

Referenced by DiffusionLHDGDirichletBC::computeResidual().

◆ deduceFunctorName() [1/2]

std::string FunctorInterface::deduceFunctorName ( const std::string & name ) const

protectedinherited

Small helper to look up a functor name through the input parameter keys.

Definition at line 71 of file FunctorInterface.C.

{
  return deduceFunctorName(name, _fi_params);
}

◆ deduceFunctorName() [2/2]

std::string FunctorInterface::deduceFunctorName	(	const std::string &	name,
		const InputParameters &	params
	)

staticinherited

Helper to look up a functor name through the input parameter keys.

Parameters

name	The input parameter name that we are trying to deduce the functor name for
params	The input parameters object that we will be checking for parameters named `name`

Returns: The functor name

Definition at line 39 of file FunctorInterface.C.

{
  if (params.isParamValid(name))
  {
    if (params.have_parameter<MooseFunctorName>(name))
      return params.get<MooseFunctorName>(name);
    // variables, functor material properties, functions, and post-processors are also functors
    else if (params.have_parameter<MaterialPropertyName>(name))
      return params.get<MaterialPropertyName>(name);
    else if (params.have_parameter<VariableName>(name))
      return params.get<VariableName>(name);
    else if (params.have_parameter<std::vector<VariableName>>(name))
    {
      const auto & var_names = params.get<std::vector<VariableName>>(name);
      if (var_names.size() != 1)
        mooseError("We only support a single variable name for retrieving a functor");
      return var_names[0];
    }
    else if (params.have_parameter<NonlinearVariableName>(name))
      return params.get<NonlinearVariableName>(name);
    else if (params.have_parameter<FunctionName>(name))
      return params.get<FunctionName>(name);
    else if (params.have_parameter<PostprocessorName>(name))
      return params.get<PostprocessorName>(name);
    else
      mooseError("Invalid parameter type for retrieving a functor");
  }
  else
    return name;
}

Referenced by FunctorInterface::checkFunctorSupportsSideIntegration(), FunctorInterface::deduceFunctorName(), FunctorInterface::getFunctor(), and FunctorInterface::isFunctor().

◆ defaultFunctor() [1/5]

template<typename T >

const Moose::Functor< T > * FunctorInterface::defaultFunctor ( const std::string & name )

privateinherited

Helper function to parse default functor values.

This is implemented as a specialization for supported types and returns NULL in all other cases.

Definition at line 254 of file FunctorInterface.h.

{
  return nullptr;
}

◆ defaultFunctor() [2/5]

template<>

const Moose::Functor< Real > * FunctorInterface::defaultFunctor ( const std::string & name )

privateinherited

◆ defaultFunctor() [3/5]

template<>

const Moose::Functor< ADReal > * FunctorInterface::defaultFunctor ( const std::string & name )

privateinherited

◆ defaultFunctor() [4/5]

template<>

const Moose::Functor< Real > * FunctorInterface::defaultFunctor ( const std::string & name )

inherited

Definition at line 78 of file FunctorInterface.C.

{
  std::istringstream ss(name);
  Real real_value;
 
  // check if the string parsed cleanly into a Real number
  if (ss >> real_value && ss.eof())
  {
    _default_real_functors.emplace_back(std::make_unique<Moose::Functor<Real>>(
        std::make_unique<Moose::ConstantFunctor<Real>>(real_value)));
    auto & default_property = _default_real_functors.back();
    return default_property.get();
  }
 
  return nullptr;
}

◆ defaultFunctor() [5/5]

template<>

const Moose::Functor< ADReal > * FunctorInterface::defaultFunctor ( const std::string & name )

inherited

Definition at line 97 of file FunctorInterface.C.

{
  std::istringstream ss(name);
  Real real_value;
 
  // check if the string parsed cleanly into a Real number
  if (ss >> real_value && ss.eof())
  {
    _default_ad_real_functors.emplace_back(std::make_unique<Moose::Functor<ADReal>>(
        std::make_unique<Moose::ConstantFunctor<ADReal>>(real_value)));
    auto & default_property = _default_ad_real_functors.back();
    return default_property.get();
  }
 
  return nullptr;
}

◆ getFunctor() [1/4]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctor ( const std::string & name )

protectedinherited

Retrieves a functor from the subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the functor parameter name, \emph not the actual name of the functor created in the input file

Returns: The functor

Definition at line 217 of file FunctorInterface.h.

{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctor<T>(name, *_fi_subproblem, _fi_tid);
}

Referenced by GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), and ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl().

◆ getFunctor() [2/4]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctor	(	const std::string &	name,
		SubProblem &	subproblem
	)

protectedinherited

Retrieves a functor from the passed-in subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the functor parameter name, \emph not the actual name of the functor created in the input file
subproblem	The subproblem to query for the functor

Returns: The functor

Definition at line 202 of file FunctorInterface.h.

{
  return getFunctor<T>(name, subproblem, _fi_tid);
}

◆ getFunctor() [3/4]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctor	(	const std::string &	name,
		SubProblem &	subproblem,
		THREAD_ID	tid
	)

protectedinherited

Retrieves a functor from the passed-in subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the functor parameter name, \emph not the actual name of the functor created in the input file
subproblem	The subproblem to query for the functor
tid	The thread ID used to retrieve the functor from the `subproblem`

Returns: The functor

Definition at line 193 of file FunctorInterface.h.

{
  // Check if the supplied parameter is a valid input parameter key
  std::string functor_name = deduceFunctorName(name);
  return getFunctorByName<T>(functor_name, subproblem, tid);
}

◆ getFunctor() [4/4]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctor	(	const std::string &	name,
		THREAD_ID	tid
	)

protectedinherited

Retrieves a functor from the subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the functor parameter name, \emph not the actual name of the functor created in the input file
tid	The thread ID used to retrieve the functor from this interface's subproblem

Returns: The functor

Definition at line 209 of file FunctorInterface.h.

{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctor<T>(name, *_fi_subproblem, tid);
}

◆ getFunctorByName() [1/2]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctorByName ( const std::string & name )

protectedinherited

Retrieves a functor from the subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the actual name of the functor created in the input file

Returns: The functor

Definition at line 225 of file FunctorInterface.h.

{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctorByName<T>(name, *_fi_subproblem, _fi_tid);
}

◆ getFunctorByName() [2/2]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctorByName	(	const std::string &	name,
		SubProblem &	subproblem,
		THREAD_ID	tid
	)

privateinherited

Retrieves a functor from the passed-in subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The actual name of the functor to retrieve instead of the parameter name
subproblem	The subproblem to query for the functor
tid	The thread ID used to retrieve the functor from the `subproblem`

Returns: The functor

Definition at line 233 of file FunctorInterface.h.

{
  // Check if it's just a constant
  const auto * const default_functor = defaultFunctor<T>(name);
  if (default_functor)
    return *default_functor;
 
  return subproblem.getFunctor<T>(name, tid, _fi_name, isADObject());
}

◆ isADObject()

virtual bool ADFunctorInterface::isADObject ( ) const

inlineoverrideprivatevirtualinherited

Whether this interface is for an AD object.

Implements FunctorInterface.

Definition at line 34 of file ADFunctorInterface.h.

34{ return true; }

◆ isFunctor() [1/2]

bool FunctorInterface::isFunctor ( const std::string & name ) const

protectedinherited

Checks the subproblem for the given functor.

This will not query default functors potentially stored in this object, e.g. this method will return false if the user passed an int or real to the functor param in the input file

Parameters

name	The name of the functor to check. This should match the functor parameter name, \emph not the actual name of the functor created in the input file

Returns: Whether the subproblem has the specified functor

Definition at line 124 of file FunctorInterface.C.

{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return isFunctor(name, *_fi_subproblem);
}

Referenced by FunctorInterface::isFunctor().

◆ isFunctor() [2/2]

bool FunctorInterface::isFunctor	(	const std::string &	name,
		const SubProblem &	subproblem
	)		const

protectedinherited

Checks the passed-in subproblem for the given functor.

This will not query default functors potentially stored in this object, e.g. this method will return false if the user passed an int or real to the functor param in the input file

Parameters

name	The name of the functor to check. This should match the functor parameter name, \emph not the actual name of the functor created in the input file
subproblem	The subproblem to query for the functor

Returns: Whether the subproblem has the specified functor

Definition at line 115 of file FunctorInterface.C.

{
  // Check if the supplied parameter is a valid input parameter key
  std::string functor_name = deduceFunctorName(name);
 
  return subproblem.hasFunctor(functor_name, _fi_tid);
}

◆ lmFaceJacobian()

void DiffusionLHDGAssemblyHelper::lmFaceJacobian	(	const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseMatrix< Number > &	lm_vec_jac,
		DenseMatrix< Number > &	lm_scalar_jac,
		DenseMatrix< Number > &	lm_lm_jac
	)

protected

Computes a local Jacobian matrix for the weak form: -<Dq*n, \mu> + <\tau * (u - \hat{u}) * n * n, \mu>

Definition at line 301 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const auto vector_qp_term = JxW_face[qp] * _diff[qp] * normals[qp];
    const auto stab_qp_term = JxW_face[qp] * _tau * normals[qp] * normals[qp];
 
    for (const auto i : make_range(lm_vec_jac.m()))
    {
      const auto vector_qpi_term = vector_qp_term * _lm_phi_face[i][qp];
      for (const auto j : make_range(lm_vec_jac.n()))
        lm_vec_jac(i, j) -= vector_qpi_term * _vector_phi_face[j][qp];
 
      const auto lm_qpi_term = stab_qp_term * _lm_phi_face[i][qp];
      for (const auto j : make_range(lm_scalar_jac.n()))
        lm_scalar_jac(i, j) += lm_qpi_term * _scalar_phi_face[j][qp];
      for (const auto j : make_range(lm_lm_jac.n()))
        lm_lm_jac(i, j) -= lm_qpi_term * _lm_phi_face[j][qp];
    }
  }
}

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ lmFaceResidual()

void DiffusionLHDGAssemblyHelper::lmFaceResidual	(	const MooseArray< Gradient > &	vector_sol,
		const MooseArray< Number > &	scalar_sol,
		const MooseArray< Number > &	lm_sol,
		const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseVector< Number > &	lm_re
	)

protected

Computes a local residual vector for the weak form: -<Dq*n, \mu> + <\tau * (u - \hat{u}) * n * n, \mu>

Definition at line 277 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    // vector
    const auto vector_qp_term = JxW_face[qp] * _diff[qp] * (vector_sol[qp] * normals[qp]);
    // stabilization term
    const auto stab_qp_term = JxW_face[qp] * _tau * (normals[qp] * normals[qp]);
    // scalar from stabilization term
    const auto scalar_qp_term = stab_qp_term * scalar_sol[qp];
    // lm from stabilization term
    const auto lm_qp_term = stab_qp_term * lm_sol[qp];
    for (const auto i : index_range(lm_re))
      lm_re(i) += _lm_phi_face[i][qp] * (scalar_qp_term - vector_qp_term - lm_qp_term);
  }
}

Referenced by DiffusionLHDGPrescribedGradientBC::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ makeElemArg()

Moose::ElemArg FunctorInterface::makeElemArg	(	const Elem *	elem,
		bool	correct_skewnewss = `false`
	)		const

protectedinherited

Helper method to create an elemental argument for a functor that includes whether to perform skewness corrections.

Definition at line 131 of file FunctorInterface.C.

{
  return {elem, correct_skewness};
}

Referenced by LinearFVAdvectionDiffusionFunctorDirichletBC::computeBoundaryNormalGradient(), LinearFVReaction::computeMatrixContribution(), LinearFVTimeDerivative::computeMatrixContribution(), FVCoupledForce::computeQpResidual(), FVFunctorTimeKernel::computeQpResidual(), FVMassMatrix::computeQpResidual(), FVBoundedValueConstraint::computeQpResidual(), FVIntegralValueConstraint::computeQpResidual(), FVPointValueConstraint::computeQpResidual(), LinearFVSource::computeRightHandSideContribution(), FunctorAux::computeValue(), FunctorCoordinatesFunctionAux::computeValue(), SecondTimeDerivativeAux::computeValue(), TimeDerivativeAux::computeValue(), LinearFVAnisotropicDiffusion::faceDiffusionTensor(), FunctorTimes::initialize(), and LinearFVTimeDerivative::setCurrentElemInfo().

◆ scalarDirichletJacobian()

void DiffusionLHDGAssemblyHelper::scalarDirichletJacobian	(	const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseMatrix< Number > &	scalar_vector_jac,
		DenseMatrix< Number > &	scalar_scalar_jac
	)

protected

Computes the Jacobian for a Dirichlet condition for the scalar field in the scalar field equation.

Definition at line 379 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const auto vector_qp_term = JxW_face[qp] * _diff[qp] * normals[qp];
    const auto scalar_qp_term = JxW_face[qp] * _tau * normals[qp] * normals[qp];
    for (const auto i : index_range(_u_dof_indices))
    {
      const auto vector_qpi_term = vector_qp_term * _scalar_phi_face[i][qp];
      for (const auto j : index_range(_qu_dof_indices))
        scalar_vector_jac(i, j) -= vector_qpi_term * _vector_phi_face[j][qp];
 
      const auto scalar_qpi_term = scalar_qp_term * _scalar_phi_face[i][qp];
      for (const auto j : index_range(_u_dof_indices))
        scalar_scalar_jac(i, j) += scalar_qpi_term * _scalar_phi_face[j][qp];
    }
  }
}

Referenced by DiffusionLHDGDirichletBC::computeJacobian().

◆ scalarDirichletResidual()

void DiffusionLHDGAssemblyHelper::scalarDirichletResidual	(	const MooseArray< Gradient > &	vector_sol,
		const MooseArray< Number > &	scalar_sol,
		const Moose::Functor< Real > &	dirichlet_value,
		const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		const Elem *const	current_elem,
		const unsigned int	current_side,
		const MooseArray< Point > &	q_point_face,
		DenseVector< Number > &	scalar_re
	)

protected

Weakly imposes a Dirichlet condition for the scalar field in the scalar field equation.

Definition at line 352 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const auto scalar_value = dirichlet_value(
        Moose::ElemSideQpArg{current_elem, current_side, qp, &qrule_face, q_point_face[qp]},
        _ti.determineState());
    const auto vector_qp_term = JxW_face[qp] * _diff[qp] * (vector_sol[qp] * normals[qp]);
    const auto stab_qp_term = JxW_face[qp] * _tau * normals[qp] * normals[qp];
    const auto scalar_qp_term = stab_qp_term * scalar_sol[qp];
    const auto lm_qp_term = stab_qp_term * scalar_value;
 
    for (const auto i : index_range(_u_dof_indices))
      scalar_re(i) += (scalar_qp_term - vector_qp_term - lm_qp_term) * _scalar_phi_face[i][qp];
  }
}

Referenced by DiffusionLHDGDirichletBC::computeResidual().

◆ scalarFaceJacobian()

void DiffusionLHDGAssemblyHelper::scalarFaceJacobian	(	const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseMatrix< Number > &	scalar_vector_jac,
		DenseMatrix< Number > &	scalar_scalar_jac,
		DenseMatrix< Number > &	scalar_lm_jac
	)

protected

Computes a local Jacobian matrix for the weak form: -<Dq*n, w> + <\tau * (u - \hat{u}) * n * n, w>

Definition at line 249 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const auto vector_qp_term = JxW_face[qp] * _diff[qp] * normals[qp];
    const auto stab_qp_term = JxW_face[qp] * _tau * normals[qp] * normals[qp];
 
    for (const auto i : make_range(scalar_vector_jac.m()))
    {
      const auto vector_qpi_term = vector_qp_term * _scalar_phi_face[i][qp];
      for (const auto j : make_range(scalar_vector_jac.n()))
        scalar_vector_jac(i, j) -= vector_qpi_term * _vector_phi_face[j][qp];
 
      const auto scalar_qpi_term = stab_qp_term * _scalar_phi_face[i][qp];
      for (const auto j : make_range(scalar_scalar_jac.n()))
        scalar_scalar_jac(i, j) += scalar_qpi_term * _scalar_phi_face[j][qp];
      for (const auto j : make_range(scalar_lm_jac.n()))
        scalar_lm_jac(i, j) -= scalar_qpi_term * _lm_phi_face[j][qp];
    }
  }
}

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ scalarFaceResidual()

void DiffusionLHDGAssemblyHelper::scalarFaceResidual	(	const MooseArray< Gradient > &	vector_sol,
		const MooseArray< Number > &	scalar_sol,
		const MooseArray< Number > &	lm_sol,
		const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseVector< Number > &	scalar_re
	)

protected

Computes a local residual vector for the weak form: -<Dq*n, w> + <\tau * (u - \hat{u}) * n * n, w>

Definition at line 225 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    // vector
    const auto vector_qp_term = JxW_face[qp] * _diff[qp] * (vector_sol[qp] * normals[qp]);
    // stabilization term
    const auto stab_qp_term = JxW_face[qp] * _tau * (normals[qp] * normals[qp]);
    // scalar from stabilization term
    const auto scalar_qp_term = stab_qp_term * scalar_sol[qp];
    // lm from stabilization term
    const auto lm_qp_term = stab_qp_term * lm_sol[qp];
    for (const auto i : index_range(scalar_re))
      scalar_re(i) += _scalar_phi_face[i][qp] * (scalar_qp_term - vector_qp_term - lm_qp_term);
  }
}

Referenced by DiffusionLHDGPrescribedGradientBC::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ scalarVolumeJacobian()

void DiffusionLHDGAssemblyHelper::scalarVolumeJacobian	(	const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		DenseMatrix< Number > &	scalar_vector_jac
	)

protected

Computes a local Jacobian matrix for the weak form: (Dq, grad(w)) - (f, w) where D is the diffusivity, w are the test functions associated with the scalar field, and f is a forcing function.

Definition at line 172 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule.n_points()))
  {
    const auto qp_term = JxW[qp] * _diff[qp];
    for (const auto i : make_range(scalar_vector_jac.m()))
    {
      const auto qpi_term = qp_term * _grad_scalar_phi[i][qp];
      // Scalar equation dependence on vector dofs
      for (const auto j : make_range(scalar_vector_jac.n()))
        scalar_vector_jac(i, j) += qpi_term * _vector_phi[j][qp];
    }
  }
}

Referenced by DiffusionLHDGKernel::computeJacobian().

◆ scalarVolumeResidual()

void DiffusionLHDGAssemblyHelper::scalarVolumeResidual	(	const MooseArray< Gradient > &	vector_field,
		const Moose::Functor< Real > &	source,
		const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		const Elem *const	current_elem,
		const MooseArray< Point > &	q_point,
		DenseVector< Number > &	scalar_re
	)

protected

Computes a local residual vector for the weak form: (Dq, grad(w)) - (f, w) where D is the diffusivity, w are the test functions associated with the scalar field, and f is a forcing function.

Definition at line 145 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule.n_points()))
  {
    const auto vector_qp_term = JxW[qp] * _diff[qp] * vector_field[qp];
    // Evaluate source
    const auto f =
        source(Moose::ElemQpArg{current_elem, qp, &qrule, q_point[qp]}, _ti.determineState());
    const auto source_qp_term = JxW[qp] * f;
 
    for (const auto i : index_range(scalar_re))
    {
      scalar_re(i) += _grad_scalar_phi[i][qp] * vector_qp_term;
 
      // Scalar equation RHS
      scalar_re(i) -= _scalar_phi[i][qp] * source_qp_term;
    }
  }
}

Referenced by DiffusionLHDGKernel::computeResidual().

◆ validParams()

InputParameters DiffusionLHDGAssemblyHelper::validParams ( )

static

Definition at line 22 of file DiffusionLHDGAssemblyHelper.C.

{
  auto params = emptyInputParameters();
  params.addRequiredParam<NonlinearVariableName>(
      "gradient_variable", "The gradient of the diffusing specie concentration");
  params.addRequiredParam<NonlinearVariableName>(
      "face_variable", "The concentration of the diffusing specie on faces");
  params.addRequiredParam<MaterialPropertyName>("diffusivity", "The diffusivity");
  params.addParam<Real>("tau",
                        1,
                        "The stabilization coefficient required for discontinuous Galerkin "
                        "schemes. This may be set to 0 for a mixed method with Raviart-Thomas.");
  return params;
}

Referenced by DiffusionLHDGDirichletBC::validParams(), DiffusionLHDGPrescribedGradientBC::validParams(), and DiffusionLHDGKernel::validParams().

◆ vectorDirichletResidual()

void DiffusionLHDGAssemblyHelper::vectorDirichletResidual	(	const Moose::Functor< Real > &	dirichlet_value,
		const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		const Elem *const	current_elem,
		const unsigned int	current_side,
		const MooseArray< Point > &	q_point_face,
		DenseVector< Number > &	vector_re
	)

protected

Weakly imposes a Dirichlet condition for the scalar field in the vector (gradient) equation.

Definition at line 329 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const auto scalar_value = dirichlet_value(
        Moose::ElemSideQpArg{current_elem, current_side, qp, &qrule_face, q_point_face[qp]},
        _ti.determineState());
    const auto qp_term = JxW_face[qp] * normals[qp] * scalar_value;
 
    // External boundary -> Dirichlet faces -> Vector equation RHS
    for (const auto i : index_range(_qu_dof_indices))
      vector_re(i) -= qp_term * _vector_phi_face[i][qp];
  }
}

Referenced by DiffusionLHDGDirichletBC::computeResidual().

◆ vectorFaceJacobian()

void DiffusionLHDGAssemblyHelper::vectorFaceJacobian	(	const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseMatrix< Number > &	vector_lm_jac
	)

protected

Computes a local Jacobian matrix for the weak form: -<\hat{u}, n*v> where \hat{u} is the trace of the scalar field, n is the normal vector, and v are the test functions associated with the gradient field.

Definition at line 206 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const auto qp_term = JxW_face[qp] * normals[qp];
    // Vector equation dependence on LM dofs
    for (const auto i : make_range(vector_lm_jac.m()))
    {
      const auto qpi_term = qp_term * _vector_phi_face[i][qp];
      for (const auto j : make_range(vector_lm_jac.n()))
        vector_lm_jac(i, j) -= qpi_term * _lm_phi_face[j][qp];
    }
  }
}

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ vectorFaceResidual()

void DiffusionLHDGAssemblyHelper::vectorFaceResidual	(	const MooseArray< Number > &	lm_sol,
		const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseVector< Number > &	vector_re
	)

protected

Computes a local residual vector for the weak form: -<\hat{u}, n*v> where \hat{u} is the trace of the scalar field, n is the normal vector, and v are the test functions associated with the gradient field.

Definition at line 190 of file DiffusionLHDGAssemblyHelper.C.

{
  // Vector equation dependence on LM dofs
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const auto qp_term = JxW_face[qp] * lm_sol[qp] * normals[qp];
    for (const auto i : index_range(vector_re))
      vector_re(i) -= _vector_phi_face[i][qp] * qp_term;
  }
}

Referenced by DiffusionLHDGPrescribedGradientBC::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ vectorVolumeJacobian()

void DiffusionLHDGAssemblyHelper::vectorVolumeJacobian	(	const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		DenseMatrix< Number > &	vector_vector_jac,
		DenseMatrix< Number > &	vector_scalar_jac
	)

protected

Computes a local Jacobian matrix for the weak form: (q, v) + (u, div(v)) where q is the vector field representing the gradient, v are its associated test functions, and u is the scalar field.

Definition at line 124 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule.n_points()))
    for (const auto i : make_range(vector_vector_jac.m()))
    {
      // Vector equation dependence on vector dofs
      const auto vector_qpi_term = JxW[qp] * _vector_phi[i][qp];
      for (const auto j : make_range(vector_vector_jac.n()))
        vector_vector_jac(i, j) += vector_qpi_term * _vector_phi[j][qp];
 
      // Vector equation dependence on scalar dofs
      const auto scalar_qpi_term = JxW[qp] * _div_vector_phi[i][qp];
      for (const auto j : make_range(vector_scalar_jac.n()))
        vector_scalar_jac(i, j) += scalar_qpi_term * _scalar_phi[j][qp];
    }
}

Referenced by DiffusionLHDGKernel::computeJacobian().

◆ vectorVolumeResidual()

void DiffusionLHDGAssemblyHelper::vectorVolumeResidual	(	const MooseArray< Gradient > &	vector_sol,
		const MooseArray< Number > &	scalar_sol,
		const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		DenseVector< Number > &	vector_re
	)

protected

Computes a local residual vector for the weak form: (q, v) + (u, div(v)) where q is the vector field representing the gradient of u, v are its associated test functions, and u is the diffused scalar field.

Definition at line 102 of file DiffusionLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule.n_points()))
  {
    const auto vector_qp_term = JxW[qp] * vector_sol[qp];
    const auto scalar_qp_term = JxW[qp] * scalar_sol[qp];
    for (const auto i : index_range(vector_re))
    {
      // Vector equation dependence on vector dofs
      vector_re(i) += _vector_phi[i][qp] * vector_qp_term;
 
      // Vector equation dependence on scalar dofs
      vector_re(i) += _div_vector_phi[i][qp] * scalar_qp_term;
    }
  }
}

Referenced by DiffusionLHDGKernel::computeResidual().

Member Data Documentation

◆ _cached_elem

const Elem* DiffusionLHDGAssemblyHelper::_cached_elem

protected

A data member used for determining when to compute the Jacobian.

Definition at line 266 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeOffDiagJacobian(), DiffusionLHDGPrescribedGradientBC::computeOffDiagJacobian(), DiffusionLHDGKernel::computeOffDiagJacobian(), DiffusionLHDGDirichletBC::jacobianSetup(), DiffusionLHDGPrescribedGradientBC::jacobianSetup(), and DiffusionLHDGKernel::jacobianSetup().

◆ _default_ad_real_functors

std::vector<std::unique_ptr<Moose::Functor<ADReal> > > FunctorInterface::_default_ad_real_functors

privateinherited

Storage vector for Moose::Functor<ADReal> default objects.

Definition at line 188 of file FunctorInterface.h.

Referenced by FunctorInterface::defaultFunctor().

◆ _default_real_functors

std::vector<std::unique_ptr<Moose::Functor<Real> > > FunctorInterface::_default_real_functors

privateinherited

Storage vector for Moose::Functor<Real> default objects.

Definition at line 185 of file FunctorInterface.h.

Referenced by FunctorInterface::defaultFunctor().

◆ _dhah_fe_problem

const FEProblemBase& DiffusionLHDGAssemblyHelper::_dhah_fe_problem

private

A reference to the finite element problem used for coupling checks.

Definition at line 281 of file DiffusionLHDGAssemblyHelper.h.

Referenced by checkCoupling().

◆ _dhah_sys

const SystemBase& DiffusionLHDGAssemblyHelper::_dhah_sys

private

A reference to the nonlinear system used for coupling checks.

Definition at line 284 of file DiffusionLHDGAssemblyHelper.h.

Referenced by checkCoupling().

◆ _diff

const MaterialProperty<Real>& DiffusionLHDGAssemblyHelper::_diff

protected

The diffusivity.

Definition at line 257 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGPrescribedGradientBC::computeResidual(), lmFaceJacobian(), lmFaceResidual(), scalarDirichletJacobian(), scalarDirichletResidual(), scalarFaceJacobian(), scalarFaceResidual(), scalarVolumeJacobian(), and scalarVolumeResidual().

◆ _div_vector_phi

const MooseArray<std::vector<Real> >& DiffusionLHDGAssemblyHelper::_div_vector_phi

protected

Definition at line 249 of file DiffusionLHDGAssemblyHelper.h.

Referenced by vectorVolumeJacobian(), and vectorVolumeResidual().

◆ _fi_name

const std::string FunctorInterface::_fi_name

privateinherited

The name of the object that this interface belongs to.

Definition at line 176 of file FunctorInterface.h.

Referenced by FunctorInterface::getFunctorByName().

◆ _fi_params

const InputParameters& FunctorInterface::_fi_params

privateinherited

Parameters of the object with this interface.

Definition at line 173 of file FunctorInterface.h.

Referenced by FunctorInterface::deduceFunctorName().

◆ _fi_subproblem

SubProblem* const FunctorInterface::_fi_subproblem

privateinherited

Pointer to subproblem if the subproblem pointer parameter was set.

Definition at line 179 of file FunctorInterface.h.

Referenced by FunctorInterface::getFunctor(), FunctorInterface::getFunctor(), FunctorInterface::getFunctorByName(), and FunctorInterface::isFunctor().

◆ _fi_tid

const THREAD_ID FunctorInterface::_fi_tid

privateinherited

Current threaded it.

Definition at line 182 of file FunctorInterface.h.

Referenced by FunctorInterface::getFunctor(), FunctorInterface::getFunctor(), FunctorInterface::getFunctorByName(), and FunctorInterface::isFunctor().

◆ _grad_scalar_phi

const MooseArray<std::vector<RealVectorValue> >& DiffusionLHDGAssemblyHelper::_grad_scalar_phi

protected

Definition at line 248 of file DiffusionLHDGAssemblyHelper.h.

Referenced by scalarVolumeJacobian(), and scalarVolumeResidual().

◆ _grad_u_var

const MooseVariableFE<RealVectorValue>& DiffusionLHDGAssemblyHelper::_grad_u_var

protected

Definition at line 232 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGKernel::additionalROVariables(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), DiffusionLHDGKernel::computeJacobian(), DiffusionLHDGKernel::computeJacobianOnSide(), DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidual(), DiffusionLHDGKernel::computeResidualOnSide(), and DiffusionLHDGAssemblyHelper().

◆ _lm_lm_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_lm_lm_jac

protected

Definition at line 273 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ _lm_phi_face

const MooseArray<std::vector<Real> >& DiffusionLHDGAssemblyHelper::_lm_phi_face

protected

Definition at line 254 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), lmFaceJacobian(), lmFaceResidual(), scalarFaceJacobian(), and vectorFaceJacobian().

◆ _lm_re

DenseVector<Number> DiffusionLHDGAssemblyHelper::_lm_re

protected

Definition at line 269 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ _lm_scalar_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_lm_scalar_jac

protected

Definition at line 273 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ _lm_u_dof_indices

const std::vector<dof_id_type>& DiffusionLHDGAssemblyHelper::_lm_u_dof_indices

protected

Definition at line 238 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), DiffusionLHDGKernel::computeJacobianOnSide(), DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ _lm_u_sol

const MooseArray<Number>& DiffusionLHDGAssemblyHelper::_lm_u_sol

protected

Definition at line 243 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ _lm_vector_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_lm_vector_jac

protected

Definition at line 274 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ _moose_obj

const MooseObject& DiffusionLHDGAssemblyHelper::_moose_obj

private

A reference to our associated MooseObject for error reporting.

Definition at line 278 of file DiffusionLHDGAssemblyHelper.h.

Referenced by checkCoupling().

◆ _qu_dof_indices

const std::vector<dof_id_type>& DiffusionLHDGAssemblyHelper::_qu_dof_indices

protected

Definition at line 236 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), DiffusionLHDGKernel::computeJacobian(), DiffusionLHDGKernel::computeJacobianOnSide(), DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidual(), DiffusionLHDGKernel::computeResidualOnSide(), scalarDirichletJacobian(), and vectorDirichletResidual().

◆ _qu_sol

const MooseArray<libMesh::Gradient>& DiffusionLHDGAssemblyHelper::_qu_sol

protected

Definition at line 241 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ _scalar_lm_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_scalar_lm_jac

protected

Definition at line 273 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ _scalar_phi

const MooseArray<std::vector<Real> >& DiffusionLHDGAssemblyHelper::_scalar_phi

protected

Definition at line 247 of file DiffusionLHDGAssemblyHelper.h.

Referenced by scalarVolumeResidual(), and vectorVolumeJacobian().

◆ _scalar_phi_face

const MooseArray<std::vector<Real> >& DiffusionLHDGAssemblyHelper::_scalar_phi_face

protected

Definition at line 253 of file DiffusionLHDGAssemblyHelper.h.

Referenced by lmFaceJacobian(), scalarDirichletJacobian(), scalarDirichletResidual(), scalarFaceJacobian(), and scalarFaceResidual().

◆ _scalar_re

DenseVector<Number> DiffusionLHDGAssemblyHelper::_scalar_re

protected

Definition at line 269 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ _scalar_scalar_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_scalar_scalar_jac

protected

Definition at line 273 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ _scalar_vector_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_scalar_vector_jac

protected

Definition at line 272 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), DiffusionLHDGKernel::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ _tau

const Real DiffusionLHDGAssemblyHelper::_tau

protected

Our stabilization coefficient.

Definition at line 263 of file DiffusionLHDGAssemblyHelper.h.

Referenced by lmFaceJacobian(), lmFaceResidual(), scalarDirichletJacobian(), scalarDirichletResidual(), scalarFaceJacobian(), and scalarFaceResidual().

◆ _ti

const TransientInterface& DiffusionLHDGAssemblyHelper::_ti

protected

Reference to transient interface.

Definition at line 260 of file DiffusionLHDGAssemblyHelper.h.

Referenced by scalarDirichletResidual(), scalarVolumeResidual(), and vectorDirichletResidual().

◆ _u_dof_indices

const std::vector<dof_id_type>& DiffusionLHDGAssemblyHelper::_u_dof_indices

protected

Definition at line 237 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), DiffusionLHDGKernel::computeJacobian(), DiffusionLHDGKernel::computeJacobianOnSide(), DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidual(), DiffusionLHDGKernel::computeResidualOnSide(), scalarDirichletJacobian(), and scalarDirichletResidual().

◆ _u_face_var

const MooseVariableFE<Real>& DiffusionLHDGAssemblyHelper::_u_face_var

protected

Definition at line 233 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGKernel::additionalROVariables(), DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), DiffusionLHDGKernel::computeJacobianOnSide(), DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidualOnSide(), and DiffusionLHDGAssemblyHelper().

◆ _u_sol

const MooseArray<Number>& DiffusionLHDGAssemblyHelper::_u_sol

protected

Definition at line 242 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ _u_var

const MooseVariableFE<Real>& DiffusionLHDGAssemblyHelper::_u_var

protected

Definition at line 231 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), DiffusionLHDGKernel::computeJacobian(), DiffusionLHDGKernel::computeJacobianOnSide(), DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ _vector_lm_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_vector_lm_jac

protected

Definition at line 273 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobianOnSide().

◆ _vector_phi

const MooseArray<std::vector<RealVectorValue> >& DiffusionLHDGAssemblyHelper::_vector_phi

protected

Definition at line 246 of file DiffusionLHDGAssemblyHelper.h.

Referenced by scalarVolumeJacobian(), vectorVolumeJacobian(), and vectorVolumeResidual().

◆ _vector_phi_face

const MooseArray<std::vector<RealVectorValue> >& DiffusionLHDGAssemblyHelper::_vector_phi_face

protected

Definition at line 252 of file DiffusionLHDGAssemblyHelper.h.

Referenced by lmFaceJacobian(), scalarDirichletJacobian(), scalarFaceJacobian(), vectorDirichletResidual(), vectorFaceJacobian(), and vectorFaceResidual().

◆ _vector_re

DenseVector<Number> DiffusionLHDGAssemblyHelper::_vector_re

protected

Definition at line 269 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), DiffusionLHDGKernel::computeResidual(), and DiffusionLHDGKernel::computeResidualOnSide().

◆ _vector_scalar_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_vector_scalar_jac

protected

Definition at line 272 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobian().

◆ _vector_vector_jac

DenseMatrix<Number> DiffusionLHDGAssemblyHelper::_vector_vector_jac

protected

Definition at line 272 of file DiffusionLHDGAssemblyHelper.h.

Referenced by DiffusionLHDGPrescribedGradientBC::computeJacobian(), and DiffusionLHDGKernel::computeJacobian().

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

include/hdgkernels/DiffusionLHDGAssemblyHelper.h
src/hdgkernels/DiffusionLHDGAssemblyHelper.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DiffusionLHDGAssemblyHelper()

Member Function Documentation

◆ checkCoupling()

◆ checkFunctorSupportsSideIntegration()

◆ createIdentityJacobian()

◆ createIdentityResidual()

◆ deduceFunctorName() [1/2]

◆ deduceFunctorName() [2/2]

◆ defaultFunctor() [1/5]

◆ defaultFunctor() [2/5]

◆ defaultFunctor() [3/5]

◆ defaultFunctor() [4/5]

◆ defaultFunctor() [5/5]

◆ getFunctor() [1/4]

◆ getFunctor() [2/4]

◆ getFunctor() [3/4]

◆ getFunctor() [4/4]

◆ getFunctorByName() [1/2]

◆ getFunctorByName() [2/2]

◆ isADObject()

◆ isFunctor() [1/2]

◆ isFunctor() [2/2]

◆ lmFaceJacobian()

◆ lmFaceResidual()

◆ makeElemArg()

◆ scalarDirichletJacobian()

◆ scalarDirichletResidual()

◆ scalarFaceJacobian()

◆ scalarFaceResidual()

◆ scalarVolumeJacobian()

◆ scalarVolumeResidual()

◆ validParams()

◆ vectorDirichletResidual()

◆ vectorFaceJacobian()

◆ vectorFaceResidual()

◆ vectorVolumeJacobian()

◆ vectorVolumeResidual()

Member Data Documentation

◆ _cached_elem

◆ _default_ad_real_functors

◆ _default_real_functors

◆ _dhah_fe_problem

◆ _dhah_sys

◆ _diff

◆ _div_vector_phi

◆ _fi_name

◆ _fi_params

◆ _fi_subproblem

◆ _fi_tid

◆ _grad_scalar_phi

◆ _grad_u_var

◆ _lm_lm_jac

◆ _lm_phi_face

◆ _lm_re

◆ _lm_scalar_jac

◆ _lm_u_dof_indices

◆ _lm_u_sol

◆ _lm_vector_jac

◆ _moose_obj

◆ _qu_dof_indices

◆ _qu_sol

◆ _scalar_lm_jac

◆ _scalar_phi

◆ _scalar_phi_face

◆ _scalar_re

◆ _scalar_scalar_jac

◆ _scalar_vector_jac

◆ _tau

◆ _ti

◆ _u_dof_indices

◆ _u_face_var

◆ _u_sol