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 ()

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. More...

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. More...

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. More...

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. More...

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. More...

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: -<{u}, n*v> where {u} is the trace of the scalar field, n is the normal vector, and v are the test functions associated with the gradient field. More...

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: -<{u}, n*v> where {u} is the trace of the scalar field, n is the normal vector, and v are the test functions associated with the gradient field. More...

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> + < (u - {u}) * n * n, w> More...

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> + < (u - {u}) * n * n, w> More...

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, > + < (u - {u}) * n * n, > More...

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, > + < (u - {u}) * n * n, > More...

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. More...

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. More...

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. More...

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, {u}), or stated simply this routine can be used to drive Lagrange multiplier values on the boundary to zero. More...

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. More...

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

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

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

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

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. More...

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

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

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. More...

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

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. More...

const TransientInterface &	_ti
	Reference to transient interface. More...

const Real	_tau
	Our stabilization coefficient. More...

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

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 Attributes
const MooseObject &	_moose_obj
	A reference to our associated MooseObject for error reporting. More...

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

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

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.

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

 {
   // 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");
 }

◆ 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 236 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.

Referenced by DiffusionLHDGDirichletBC::computeJacobian().

 {
   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;
     }
 }

◆ 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, {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.

Referenced by DiffusionLHDGDirichletBC::computeResidual().

 {
   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;
   }
 }

◆ deduceFunctorName() [1/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 28 of file FunctorInterface.C.

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

 {
   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;
 }

◆ deduceFunctorName() [2/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 60 of file FunctorInterface.C.

 {
   return deduceFunctorName(name, _fi_params);
 }

◆ 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, not the actual name of the functor created in the input file

Returns: The functor

Definition at line 200 of file FunctorInterface.h.

Referenced by MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl().

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

◆ getFunctor() [2/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, 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 192 of file FunctorInterface.h.

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

◆ getFunctor() [3/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, 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 185 of file FunctorInterface.h.

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

◆ getFunctor() [4/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, 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 176 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);
 }

◆ 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, not the actual name of the functor created in the input file

Returns: Whether the subproblem has the specified functor

Definition at line 113 of file FunctorInterface.C.

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

◆ 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, 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 104 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, > + < * (u - {u}) * n * n, >

Definition at line 301 of file DiffusionLHDGAssemblyHelper.C.

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

 {
   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];
     }
   }
 }

◆ 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, > + < * (u - {u}) * n * n, >

Definition at line 277 of file DiffusionLHDGAssemblyHelper.C.

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

 {
   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);
   }
 }

◆ 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 120 of file FunctorInterface.C.

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

 {
   return {elem, correct_skewness};
 }

◆ 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.

Referenced by DiffusionLHDGDirichletBC::computeJacobian().

 {
   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];
     }
   }
 }

◆ 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.

Referenced by DiffusionLHDGDirichletBC::computeResidual().

 {
   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];
   }
 }

◆ 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> + < * (u - {u}) * n * n, w>

Definition at line 249 of file DiffusionLHDGAssemblyHelper.C.

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

 {
   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];
     }
   }
 }

◆ 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> + < * (u - {u}) * n * n, w>

Definition at line 225 of file DiffusionLHDGAssemblyHelper.C.

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

 {
   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);
   }
 }

◆ 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.

Referenced by DiffusionLHDGKernel::computeJacobian().

 {
   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];
     }
   }
 }

◆ 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.

Referenced by DiffusionLHDGKernel::computeResidual().

 {
   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;
     }
   }
 }

◆ validParams()

InputParameters DiffusionLHDGAssemblyHelper::validParams ( )

static

Definition at line 22 of file DiffusionLHDGAssemblyHelper.C.

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

 {
   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;
 }

◆ 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.

Referenced by DiffusionLHDGDirichletBC::computeResidual().

 {
   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];
   }
 }

◆ 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: -<{u}, n*v> where {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.

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

 {
   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];
     }
   }
 }

◆ 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: -<{u}, n*v> where {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.

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

 {
   // 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;
   }
 }

◆ 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.

Referenced by DiffusionLHDGKernel::computeJacobian().

 {
   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];
     }
 }

◆ 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.

Referenced by DiffusionLHDGKernel::computeResidual().

 {
   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;
     }
   }
 }