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

#include <NavierStokesLHDGAssemblyHelper.h>

Inheritance diagram for NavierStokesLHDGAssemblyHelper:

[legend]

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

void	checkCoupling ()

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

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)

Protected Member Functions
RealVectorValue	rhoVelCrossVelResidual (const MooseArray< Number > &u_sol, const MooseArray< Number > &v_sol, const unsigned int qp, const unsigned int vel_component)

RealVectorValue	rhoVelCrossVelJacobian (const MooseArray< Number > &u_sol, const MooseArray< Number > &v_sol, const unsigned int qp, const unsigned int vel_component, const unsigned int vel_j_component, const MooseArray< std::vector< Real > > &phi, const unsigned int j)

void	scalarVolumeResidual (const MooseArray< Gradient > &vel_gradient, const unsigned int vel_component, const Moose::Functor< Real > &body_force, const MooseArray< Real > &JxW, const libMesh::QBase &qrule, const Elem *const current_elem, const MooseArray< Point > &q_point, DenseVector< Number > &scalar_re)
	Compute the volumetric contributions to a velocity residual for a provided velocity gradient and stress.

void	scalarVolumeJacobian (const unsigned int vel_component, const MooseArray< Real > &JxW, const libMesh::QBase &qrule, DenseMatrix< Number > &scalar_vector_jac, DenseMatrix< Number > &scalar_u_vel_jac, DenseMatrix< Number > &scalar_v_vel_jac, DenseMatrix< Number > &scalar_p_jac)
	Compute the volumetric contributions to a velocity Jacobian.

void	pressureVolumeResidual (const Moose::Functor< Real > &pressure_mms_forcing_function, const MooseArray< Real > &JxW, const libMesh::QBase &qrule, const Elem *const current_elem, const MooseArray< Point > &q_point, DenseVector< Number > &pressure_re, DenseVector< Number > &global_lm_re)
	Compute the volumetric contributions to the pressure residual, e.g.

void	pressureVolumeJacobian (const MooseArray< Real > &JxW, const libMesh::QBase &qrule, DenseMatrix< Number > &p_u_vel_jac, DenseMatrix< Number > &p_v_vel_jac, DenseMatrix< Number > &p_global_lm_jac, DenseMatrix< Number > &global_lm_p_jac)
	Compute the volumetric contributions to the pressure Jacobian, e.g.

void	pressureFaceResidual (const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseVector< Number > &pressure_re)

void	pressureFaceJacobian (const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, DenseMatrix< Number > &p_lm_u_vel_jac, DenseMatrix< Number > &p_lm_v_vel_jac)

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

void	scalarFaceJacobian (const unsigned int vel_component, 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, DenseMatrix< Number > &scalar_p_jac, DenseMatrix< Number > &scalar_lm_u_vel_jac, DenseMatrix< Number > &scalar_lm_v_vel_jac)

void	lmFaceResidual (const MooseArray< Gradient > &vector_sol, const MooseArray< Number > &scalar_sol, const MooseArray< Number > &lm_sol, const unsigned int vel_component, const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, const Elem *const neigh, DenseVector< Number > &lm_re)

void	lmFaceJacobian (const unsigned int vel_component, const MooseArray< Real > &JxW_face, const libMesh::QBase &qrule_face, const MooseArray< Point > &normals, const Elem *const neigh, DenseMatrix< Number > &lm_vec_jac, DenseMatrix< Number > &lm_scalar_jac, DenseMatrix< Number > &lm_lm_jac, DenseMatrix< Number > &lm_p_jac, DenseMatrix< Number > &lm_lm_u_vel_jac, DenseMatrix< Number > &lm_lm_v_vel_jac)

void	pressureDirichletResidual (const std::array< const Moose::Functor< Real > , 3 > &dirichlet_vel, 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 > &pressure_re)

void	scalarDirichletResidual (const MooseArray< Gradient > &vector_sol, const MooseArray< Number > &scalar_sol, const unsigned int vel_component, const std::array< const Moose::Functor< Real > , 3 > &dirichlet_vel, 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)

void	scalarDirichletJacobian (const unsigned int vel_component, 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_pressure_jac)

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

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

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

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)

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

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)

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

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)

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)

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)

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)

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)

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)

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)

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

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

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

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

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

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

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

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

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

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

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

Protected Attributes
const MooseVariableFE< Real > &	_v_var

const MooseVariableFE< Real > *const	_w_var

const MooseVariableFE< RealVectorValue > &	_grad_v_var

const MooseVariableFE< RealVectorValue > *const	_grad_w_var

const MooseVariableFE< Real > &	_v_face_var

const MooseVariableFE< Real > *const	_w_face_var

const MooseVariableFE< Real > &	_pressure_var

const MooseVariableScalar *const	_enclosure_lm_var

const std::vector< dof_id_type > &	_qv_dof_indices
	Containers for dof indices.

const std::vector< dof_id_type > &	_v_dof_indices

const std::vector< dof_id_type > &	_lm_v_dof_indices

const std::vector< dof_id_type > *const	_qw_dof_indices

const std::vector< dof_id_type > *const	_w_dof_indices

const std::vector< dof_id_type > *const	_lm_w_dof_indices

const std::vector< dof_id_type > &	_p_dof_indices

const std::vector< dof_id_type > *const	_global_lm_dof_indices

const MooseArray< Gradient > &	_qv_sol
	local solutions at quadrature points

const MooseArray< Number > &	_v_sol

const MooseArray< Number > &	_lm_v_sol

const MooseArray< Gradient > *const	_qw_sol

const MooseArray< Number > *const	_w_sol

const MooseArray< Number > *const	_lm_w_sol

const MooseArray< Number > &	_p_sol

const MooseArray< Number > *const	_global_lm_dof_value

const Real	_rho
	The density.

DenseVector< Number >	_grad_u_vel_re

DenseVector< Number >	_grad_v_vel_re

DenseVector< Number >	_u_vel_re

DenseVector< Number >	_v_vel_re

DenseVector< Number >	_lm_u_vel_re

DenseVector< Number >	_lm_v_vel_re

DenseVector< Number >	_p_re

DenseVector< Number >	_global_lm_re

DenseMatrix< Number >	_grad_u_grad_u_jac

DenseMatrix< Number >	_grad_u_u_jac

DenseMatrix< Number >	_grad_v_grad_v_jac

DenseMatrix< Number >	_grad_v_v_jac

DenseMatrix< Number >	_u_grad_u_jac

DenseMatrix< Number >	_v_grad_v_jac

DenseMatrix< Number >	_u_u_jac

DenseMatrix< Number >	_u_v_jac

DenseMatrix< Number >	_v_u_jac

DenseMatrix< Number >	_v_v_jac

DenseMatrix< Number >	_u_p_jac

DenseMatrix< Number >	_v_p_jac

DenseMatrix< Number >	_p_u_jac

DenseMatrix< Number >	_p_v_jac

DenseMatrix< Number >	_p_global_lm_jac

DenseMatrix< Number >	_global_lm_p_jac

DenseMatrix< Number >	_grad_u_lm_u_jac

DenseMatrix< Number >	_grad_v_lm_v_jac

DenseMatrix< Number >	_u_lm_u_jac

DenseMatrix< Number >	_v_lm_v_jac

DenseMatrix< Number >	_u_lm_v_jac

DenseMatrix< Number >	_v_lm_u_jac

DenseMatrix< Number >	_lm_u_grad_u_jac

DenseMatrix< Number >	_lm_v_grad_v_jac

DenseMatrix< Number >	_lm_u_u_jac

DenseMatrix< Number >	_lm_v_v_jac

DenseMatrix< Number >	_lm_u_lm_u_jac

DenseMatrix< Number >	_lm_v_lm_v_jac

DenseMatrix< Number >	_lm_u_p_jac

DenseMatrix< Number >	_lm_v_p_jac

DenseMatrix< Number >	_lm_u_lm_v_jac

DenseMatrix< Number >	_lm_v_lm_u_jac

DenseMatrix< Number >	_p_lm_u_jac

DenseMatrix< Number >	_p_lm_v_jac

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

const TransientInterface &	_ti

const Real	_tau

const Elem *	_cached_elem

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
const Moose::Functor< T > *	defaultFunctor (const std::string &name)

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

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

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

virtual bool	isADObject () const override

Private Attributes
const MooseObject &	_moose_obj

const FEProblemBase &	_dhah_fe_problem

const SystemBase &	_dhah_sys

const InputParameters &	_fi_params

const std::string	_fi_name

SubProblem *const	_fi_subproblem

const THREAD_ID	_fi_tid

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

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

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 incompressible Navier-Stokes equations.

These routines may be called by both HDG kernels and integrated boundary conditions. The implementation here is based on "An implicit high-order hybridizable discontinuous Galerkin method for the incompressible Navier-Stokes equations" by Nguyen and Cockburn

Definition at line 21 of file NavierStokesLHDGAssemblyHelper.h.

Constructor & Destructor Documentation

◆ NavierStokesLHDGAssemblyHelper()

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

Definition at line 44 of file NavierStokesLHDGAssemblyHelper.C.

  : DiffusionLHDGAssemblyHelper(moose_obj, mpi, mvdi, ti, fe_problem, sys, tid),
    // vars
    _v_var(sys.getFieldVariable<Real>(tid, moose_obj->getParam<NonlinearVariableName>("v"))),
    _w_var(mesh.dimension() > 2
               ? &sys.getFieldVariable<Real>(tid, moose_obj->getParam<NonlinearVariableName>("w"))
               : nullptr),
    _grad_v_var(sys.getFieldVariable<RealVectorValue>(
        tid, moose_obj->getParam<NonlinearVariableName>("grad_v"))),
    _grad_w_var(mesh.dimension() > 2
                    ? &sys.getFieldVariable<RealVectorValue>(
                          tid, moose_obj->getParam<NonlinearVariableName>("grad_w"))
                    : nullptr),
    _v_face_var(
        sys.getFieldVariable<Real>(tid, moose_obj->getParam<NonlinearVariableName>("face_v"))),
    _w_face_var(
        mesh.dimension() > 2
            ? &sys.getFieldVariable<Real>(tid, moose_obj->getParam<NonlinearVariableName>("face_w"))
            : nullptr),
    _pressure_var(
        sys.getFieldVariable<Real>(tid, moose_obj->getParam<NonlinearVariableName>(NS::pressure))),
    _enclosure_lm_var(moose_obj->isParamValid("enclosure_lm")
                          ? &sys.getScalarVariable(
                                tid, moose_obj->getParam<NonlinearVariableName>("enclosure_lm"))
                          : nullptr),
    // dof indices
    _qv_dof_indices(_grad_v_var.dofIndices()),
    _v_dof_indices(_v_var.dofIndices()),
    _lm_v_dof_indices(_v_face_var.dofIndices()),
    _qw_dof_indices(_grad_w_var ? &_grad_w_var->dofIndices() : nullptr),
    _w_dof_indices(_w_var ? &_w_var->dofIndices() : nullptr),
    _lm_w_dof_indices(_w_face_var ? &_w_face_var->dofIndices() : nullptr),
    _p_dof_indices(_pressure_var.dofIndices()),
    _global_lm_dof_indices(_enclosure_lm_var ? &_enclosure_lm_var->dofIndices() : nullptr),
    // solutions
    _qv_sol(_grad_v_var.sln()),
    _v_sol(_v_var.sln()),
    _lm_v_sol(_v_face_var.sln()),
    _qw_sol(_grad_w_var ? &_grad_w_var->sln() : nullptr),
    _w_sol(_w_var ? &_w_var->sln() : nullptr),
    _lm_w_sol(_w_face_var ? &_w_face_var->sln() : nullptr),
    _p_sol(_pressure_var.sln()),
    _global_lm_dof_value(_enclosure_lm_var ? &_enclosure_lm_var->sln() : nullptr),
    _rho(moose_obj->getParam<Real>(NS::density))
{
  if (mesh.dimension() > 2)
    mooseError("3D not yet implemented");
 
  mvdi->addMooseVariableDependency(&const_cast<MooseVariableFE<Real> &>(_v_var));
  mvdi->addMooseVariableDependency(&const_cast<MooseVariableFE<RealVectorValue> &>(_grad_v_var));
  mvdi->addMooseVariableDependency(&const_cast<MooseVariableFE<Real> &>(_v_face_var));
  mvdi->addMooseVariableDependency(&const_cast<MooseVariableFE<Real> &>(_pressure_var));
 
  const auto vel_type = _u_var.feType();
  auto check_type = [&vel_type](const auto & var)
  {
    if (vel_type != var.feType())
      mooseError(
          var.name(),
          " does not have the same finite element type as the x-component velocity. All scalar "
          "field finite element types must be the same for the Navier-Stokes L-HDG implementation");
  };
  check_type(_v_var);
  if (_w_var)
    check_type(*_w_var);
  check_type(_pressure_var);
 
  const auto grad_type = _grad_u_var.feType();
  auto check_grad_type = [&grad_type](const auto & var)
  {
    if (grad_type != var.feType())
      mooseError(
          var.name(),
          "does not have the same finite element type as the x-component velocity gradient. All "
          "vector field finite element types must be the same for the Navier-Stokes L-HDG "
          "implementation");
  };
  check_grad_type(_grad_v_var);
  if (_grad_w_var)
    check_grad_type(*_grad_w_var);
 
  const auto lm_type = _u_face_var.feType();
  auto check_lm_type = [&lm_type](const auto & var)
  {
    if (lm_type != var.feType())
      mooseError(var.name(),
                 "does not have the same finite element type as the x-component face variable. All "
                 "face variable finite element types must be the same for the Navier-Stokes L-HDG "
                 "implementation");
  };
  check_lm_type(_v_face_var);
  if (_w_face_var)
    check_lm_type(*_w_face_var);
}

Member Function Documentation

◆ lmFaceJacobian()

void NavierStokesLHDGAssemblyHelper::lmFaceJacobian	(	const unsigned int	vel_component,
		const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		const Elem *const	neigh,
		DenseMatrix< Number > &	lm_vec_jac,
		DenseMatrix< Number > &	lm_scalar_jac,
		DenseMatrix< Number > &	lm_lm_jac,
		DenseMatrix< Number > &	lm_p_jac,
		DenseMatrix< Number > &	lm_lm_u_vel_jac,
		DenseMatrix< Number > &	lm_lm_v_vel_jac
	)

protected

Definition at line 478 of file NavierStokesLHDGAssemblyHelper.C.

{
  DiffusionLHDGAssemblyHelper::lmFaceJacobian(
      JxW_face, qrule_face, normals, lm_vec_jac, lm_scalar_jac, lm_lm_jac);
 
  for (const auto i : make_range(lm_p_jac.m()))
    for (const auto qp : make_range(qrule_face.n_points()))
    {
      for (const auto j : make_range(lm_p_jac.n()))
      {
        Gradient p_phi;
        p_phi(vel_component) = _scalar_phi_face[j][qp];
        lm_p_jac(i, j) += JxW_face[qp] * _lm_phi_face[i][qp] * (p_phi * normals[qp]);
      }
 
      for (const auto j : make_range(lm_lm_u_vel_jac.n()))
        if (neigh)
        {
          // derivatives wrt 0th component of velocity
          {
            const auto rho_vel_cross_vel =
                rhoVelCrossVelJacobian(_lm_u_sol, _lm_v_sol, qp, vel_component, 0, _lm_phi_face, j);
            lm_lm_u_vel_jac(i, j) +=
                JxW_face[qp] * _lm_phi_face[i][qp] * rho_vel_cross_vel * normals[qp];
          }
          // derivatives wrt 1th component of velocity
          {
            const auto rho_vel_cross_vel =
                rhoVelCrossVelJacobian(_lm_u_sol, _lm_v_sol, qp, vel_component, 1, _lm_phi_face, j);
            lm_lm_v_vel_jac(i, j) +=
                JxW_face[qp] * _lm_phi_face[i][qp] * rho_vel_cross_vel * normals[qp];
          }
        }
    }
}

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ lmFaceResidual()

void NavierStokesLHDGAssemblyHelper::lmFaceResidual	(	const MooseArray< Gradient > &	vector_sol,
		const MooseArray< Number > &	scalar_sol,
		const MooseArray< Number > &	lm_sol,
		const unsigned int	vel_component,
		const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		const Elem *const	neigh,
		DenseVector< Number > &	lm_re
	)

protected

Definition at line 444 of file NavierStokesLHDGAssemblyHelper.C.

{
  DiffusionLHDGAssemblyHelper::lmFaceResidual(
      vector_sol, scalar_sol, lm_sol, JxW_face, qrule_face, normals, lm_re);
 
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    Gradient qp_p;
    qp_p(vel_component) = _p_sol[qp];
    const auto rho_vel_cross_vel = rhoVelCrossVelResidual(_lm_u_sol, _lm_v_sol, qp, vel_component);
 
    for (const auto i : make_range(lm_re.size()))
    {
      // pressure
      lm_re(i) += JxW_face[qp] * _lm_phi_face[i][qp] * (qp_p * normals[qp]);
 
      // If we are an internal face we add the convective term. On the outflow boundary we do not
      // zero out the convection term, e.g. we are going to set q + p + tau * (u - u_hat) to zero
      if (neigh)
        // lm from convection term
        lm_re(i) += JxW_face[qp] * _lm_phi_face[i][qp] * rho_vel_cross_vel * normals[qp];
    }
  }
}

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ pressureDirichletResidual()

void NavierStokesLHDGAssemblyHelper::pressureDirichletResidual	(	const std::array< const Moose::Functor< Real > *, 3 > &	dirichlet_vel,
		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 > &	pressure_re
	)

protected

Definition at line 525 of file NavierStokesLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const Moose::ElemSideQpArg elem_side_qp_arg{
        current_elem, current_side, qp, &qrule_face, q_point_face[qp]};
    const auto time_arg = _ti.determineState();
    const RealVectorValue dirichlet_velocity((*dirichlet_vel[0])(elem_side_qp_arg, time_arg),
                                             (*dirichlet_vel[1])(elem_side_qp_arg, time_arg),
                                             (*dirichlet_vel[2])(elem_side_qp_arg, time_arg));
    const auto vdotn = dirichlet_velocity * normals[qp];
    for (const auto i : make_range(pressure_re.size()))
      pressure_re(i) += JxW_face[qp] * vdotn * _scalar_phi_face[i][qp];
  }
}

Referenced by NavierStokesLHDGVelocityDirichletBC::computeResidual().

◆ pressureFaceJacobian()

void NavierStokesLHDGAssemblyHelper::pressureFaceJacobian	(	const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseMatrix< Number > &	p_lm_u_vel_jac,
		DenseMatrix< Number > &	p_lm_v_vel_jac
	)

protected

Definition at line 337 of file NavierStokesLHDGAssemblyHelper.C.

{
  mooseAssert((p_lm_u_vel_jac.m() == p_lm_v_vel_jac.m()) &&
                  (p_lm_u_vel_jac.n() == p_lm_v_vel_jac.n()),
              "We already checked that lm finite element types are the same, so these matrices "
              "should be the same size");
  for (const auto i : make_range(p_lm_u_vel_jac.m()))
    for (const auto j : make_range(p_lm_u_vel_jac.n()))
      for (const auto qp : make_range(qrule_face.n_points()))
      {
        {
          const Gradient phi(_lm_phi_face[j][qp], 0);
          p_lm_u_vel_jac(i, j) += JxW_face[qp] * phi * normals[qp] * _scalar_phi_face[i][qp];
        }
        {
          const Gradient phi(0, _lm_phi_face[j][qp]);
          p_lm_v_vel_jac(i, j) += JxW_face[qp] * phi * normals[qp] * _scalar_phi_face[i][qp];
        }
      }
}

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ pressureFaceResidual()

void NavierStokesLHDGAssemblyHelper::pressureFaceResidual	(	const MooseArray< Real > &	JxW_face,
		const libMesh::QBase &	qrule_face,
		const MooseArray< Point > &	normals,
		DenseVector< Number > &	pressure_re
	)

protected

Definition at line 322 of file NavierStokesLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    const Gradient vel(_lm_u_sol[qp], _lm_v_sol[qp]);
    const auto vdotn = vel * normals[qp];
    for (const auto i : make_range(pressure_re.size()))
      pressure_re(i) += JxW_face[qp] * vdotn * _scalar_phi_face[i][qp];
  }
}

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ pressureVolumeJacobian()

void NavierStokesLHDGAssemblyHelper::pressureVolumeJacobian	(	const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		DenseMatrix< Number > &	p_u_vel_jac,
		DenseMatrix< Number > &	p_v_vel_jac,
		DenseMatrix< Number > &	p_global_lm_jac,
		DenseMatrix< Number > &	global_lm_p_jac
	)

protected

Compute the volumetric contributions to the pressure Jacobian, e.g.

the conservation of mass equation

Parameters

i_offset	The local degree of freedom offset for the pressure
u_j_offset	The local degree of freedom offset for the x-component of velocity
v_j_offset	The local degree of freedom offset for the y-component of velocity
p_j_offset	The local degree of freedom offset for the pressure
global_lm_i_offset	The local degree of freedom offset for the global Lagrange multiplier that removes the pressure nullspace

Definition at line 258 of file NavierStokesLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule.n_points()))
  {
    for (const auto i : make_range(p_u_vel_jac.m()))
    {
      for (const auto j : make_range(p_u_vel_jac.n()))
      {
        {
          const Gradient phi(_scalar_phi[j][qp], 0);
          p_u_vel_jac(i, j) -= JxW[qp] * (_grad_scalar_phi[i][qp] * phi);
        }
        {
          const Gradient phi(0, _scalar_phi[j][qp]);
          p_v_vel_jac(i, j) -= JxW[qp] * (_grad_scalar_phi[i][qp] * phi);
        }
      }
      if (_enclosure_lm_var)
        p_global_lm_jac(i, 0) -= JxW[qp] * _scalar_phi[i][qp];
    }
 
    if (_enclosure_lm_var)
    {
      for (const auto j : make_range(global_lm_p_jac.n()))
        global_lm_p_jac(0, j) -= JxW[qp] * _scalar_phi[j][qp];
    }
  }
}

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ pressureVolumeResidual()

void NavierStokesLHDGAssemblyHelper::pressureVolumeResidual	(	const Moose::Functor< Real > &	pressure_mms_forcing_function,
		const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		const Elem *const	current_elem,
		const MooseArray< Point > &	q_point,
		DenseVector< Number > &	pressure_re,
		DenseVector< Number > &	global_lm_re
	)

protected

Compute the volumetric contributions to the pressure residual, e.g.

the conservation of mass equation

Parameters

i_offset	The local degree of freedom offset for the pressure
global_lm_i_offset	The local degree of freedom offset for the global Lagrange multiplier that removes the pressure nullspace

Definition at line 220 of file NavierStokesLHDGAssemblyHelper.C.

{
  for (const auto qp : make_range(qrule.n_points()))
  {
    // Prepare forcing function
    const auto f = pressure_mms_forcing_function(
        Moose::ElemQpArg{current_elem, qp, &qrule, q_point[qp]}, _ti.determineState());
 
    const Gradient vel(_u_sol[qp], _v_sol[qp]);
    for (const auto i : make_range(pressure_re.size()))
    {
      pressure_re(i) -= JxW[qp] * (_grad_scalar_phi[i][qp] * vel);
 
      // Pressure equation forcing function RHS
      pressure_re(i) -= JxW[qp] * _scalar_phi[i][qp] * f;
 
      if (_enclosure_lm_var)
      {
        mooseAssert(
            _global_lm_dof_value->size() == 1,
            "There should only be one degree of freedom for removing the pressure nullspace");
        pressure_re(i) -= JxW[qp] * _scalar_phi[i][qp] * (*_global_lm_dof_value)[0];
      }
    }
 
    if (_enclosure_lm_var)
      global_lm_re(0) -= JxW[qp] * _p_sol[qp];
  }
}

Referenced by NavierStokesLHDGKernel::computeResidual().

◆ rhoVelCrossVelJacobian()

RealVectorValue NavierStokesLHDGAssemblyHelper::rhoVelCrossVelJacobian	(	const MooseArray< Number > &	u_sol,
		const MooseArray< Number > &	v_sol,
		const unsigned int	qp,
		const unsigned int	vel_component,
		const unsigned int	vel_j_component,
		const MooseArray< std::vector< Real > > &	phi,
		const unsigned int	j
	)

protected

Parameters

u_sol	The x-velocity solution, can correspond to either the volumetric or face velocity
v_sol	The y-velocity solution, can correspond to either the volumetric or face velocity

Definition at line 303 of file NavierStokesLHDGAssemblyHelper.C.

{
  const RealVectorValue U(u_sol[qp], v_sol[qp]);
  RealVectorValue vector_phi;
  vector_phi(vel_j_component) = phi[j][qp];
  auto ret = vector_phi * U(vel_component);
  if (vel_component == vel_j_component)
    ret += U * phi[j][qp];
  ret *= _rho;
  return ret;
}

Referenced by lmFaceJacobian(), scalarFaceJacobian(), and scalarVolumeJacobian().

◆ rhoVelCrossVelResidual()

RealVectorValue NavierStokesLHDGAssemblyHelper::rhoVelCrossVelResidual	(	const MooseArray< Number > &	u_sol,
		const MooseArray< Number > &	v_sol,
		const unsigned int	qp,
		const unsigned int	vel_component
	)

protected

Parameters

u_sol	The x-velocity solution, can correspond to either the volumetric or face velocity
v_sol	The y-velocity solution, can correspond to either the volumetric or face velocity

Definition at line 293 of file NavierStokesLHDGAssemblyHelper.C.

{
  const RealVectorValue U(u_sol[qp], v_sol[qp]);
  return _rho * U * U(vel_component);
}

Referenced by lmFaceResidual(), scalarFaceResidual(), and scalarVolumeResidual().

◆ scalarDirichletJacobian()

void NavierStokesLHDGAssemblyHelper::scalarDirichletJacobian	(	const unsigned int	vel_component,
		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_pressure_jac
	)

protected

Definition at line 600 of file NavierStokesLHDGAssemblyHelper.C.

{
  DiffusionLHDGAssemblyHelper::scalarDirichletJacobian(
      JxW_face, qrule_face, normals, scalar_vector_jac, scalar_scalar_jac);
 
  for (const auto i : make_range(scalar_pressure_jac.m()))
    for (const auto j : make_range(scalar_pressure_jac.n()))
      for (const auto qp : make_range(qrule_face.n_points()))
      {
        Gradient p_phi;
        p_phi(vel_component) = _scalar_phi_face[j][qp];
        // pressure
        scalar_pressure_jac(i, j) += JxW_face[qp] * _scalar_phi_face[i][qp] * (p_phi * normals[qp]);
      }
}

Referenced by NavierStokesLHDGVelocityDirichletBC::computeJacobian().

◆ scalarDirichletResidual()

void NavierStokesLHDGAssemblyHelper::scalarDirichletResidual	(	const MooseArray< Gradient > &	vector_sol,
		const MooseArray< Number > &	scalar_sol,
		const unsigned int	vel_component,
		const std::array< const Moose::Functor< Real > *, 3 > &	dirichlet_vel,
		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

Definition at line 550 of file NavierStokesLHDGAssemblyHelper.C.

{
  DiffusionLHDGAssemblyHelper::scalarDirichletResidual(vector_sol,
                                                       scalar_sol,
                                                       *dirichlet_vel[vel_component],
                                                       JxW_face,
                                                       qrule_face,
                                                       normals,
                                                       current_elem,
                                                       current_side,
                                                       q_point_face,
                                                       scalar_re);
 
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    Gradient qp_p;
    qp_p(vel_component) = _p_sol[qp];
 
    const Moose::ElemSideQpArg elem_side_qp_arg{
        current_elem, current_side, qp, &qrule_face, q_point_face[qp]};
    const auto time_arg = _ti.determineState();
    const RealVectorValue dirichlet_velocity((*dirichlet_vel[0])(elem_side_qp_arg, time_arg),
                                             (*dirichlet_vel[1])(elem_side_qp_arg, time_arg),
                                             (*dirichlet_vel[2])(elem_side_qp_arg, time_arg));
    const auto scalar_value = dirichlet_velocity(vel_component);
 
    for (const auto i : make_range(scalar_re.size()))
    {
      // pressure
      scalar_re(i) += JxW_face[qp] * _scalar_phi_face[i][qp] * (qp_p * normals[qp]);
 
      // dirichlet lm from advection term
      scalar_re(i) += JxW_face[qp] * _scalar_phi_face[i][qp] *
                      (_rho * dirichlet_velocity * normals[qp]) * scalar_value;
    }
  }
}

Referenced by NavierStokesLHDGVelocityDirichletBC::computeResidual().

◆ scalarFaceJacobian()

void NavierStokesLHDGAssemblyHelper::scalarFaceJacobian	(	const unsigned int	vel_component,
		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,
		DenseMatrix< Number > &	scalar_p_jac,
		DenseMatrix< Number > &	scalar_lm_u_vel_jac,
		DenseMatrix< Number > &	scalar_lm_v_vel_jac
	)

protected

Definition at line 393 of file NavierStokesLHDGAssemblyHelper.C.

{
  DiffusionLHDGAssemblyHelper::scalarFaceJacobian(
      JxW_face, qrule_face, normals, scalar_vector_jac, scalar_scalar_jac, scalar_lm_jac);
 
  for (const auto i : make_range(scalar_lm_u_vel_jac.m()))
    for (const auto qp : make_range(qrule_face.n_points()))
    {
      for (const auto j : make_range(scalar_p_jac.n()))
      {
        Gradient p_phi;
        p_phi(vel_component) = _scalar_phi_face[j][qp];
        // pressure
        scalar_p_jac(i, j) += JxW_face[qp] * _scalar_phi_face[i][qp] * (p_phi * normals[qp]);
      }
 
      for (const auto j : make_range(scalar_lm_u_vel_jac.n()))
      {
        //
        // from convection term
        //
 
        // derivatives wrt 0th component of velocity
        {
          const auto rho_vel_cross_vel =
              rhoVelCrossVelJacobian(_lm_u_sol, _lm_v_sol, qp, vel_component, 0, _lm_phi_face, j);
          scalar_lm_u_vel_jac(i, j) +=
              JxW_face[qp] * _scalar_phi_face[i][qp] * rho_vel_cross_vel * normals[qp];
        }
        // derivatives wrt 1th component of velocity
        {
          const auto rho_vel_cross_vel =
              rhoVelCrossVelJacobian(_lm_u_sol, _lm_v_sol, qp, vel_component, 1, _lm_phi_face, j);
          scalar_lm_v_vel_jac(i, j) +=
              JxW_face[qp] * _scalar_phi_face[i][qp] * rho_vel_cross_vel * normals[qp];
        }
      }
    }
}

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ scalarFaceResidual()

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

protected

Definition at line 363 of file NavierStokesLHDGAssemblyHelper.C.

{
  DiffusionLHDGAssemblyHelper::scalarFaceResidual(
      vector_sol, scalar_sol, lm_sol, JxW_face, qrule_face, normals, scalar_re);
 
  for (const auto qp : make_range(qrule_face.n_points()))
  {
    Gradient qp_p;
    qp_p(vel_component) = _p_sol[qp];
    const auto rho_vel_cross_vel = rhoVelCrossVelResidual(_lm_u_sol, _lm_v_sol, qp, vel_component);
 
    for (const auto i : make_range(scalar_re.size()))
    {
      // pressure
      scalar_re(i) += JxW_face[qp] * _scalar_phi_face[i][qp] * (qp_p * normals[qp]);
 
      // lm from convection term
      scalar_re(i) += JxW_face[qp] * _scalar_phi_face[i][qp] * rho_vel_cross_vel * normals[qp];
    }
  }
}

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ scalarVolumeJacobian()

void NavierStokesLHDGAssemblyHelper::scalarVolumeJacobian	(	const unsigned int	vel_component,
		const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		DenseMatrix< Number > &	scalar_vector_jac,
		DenseMatrix< Number > &	scalar_u_vel_jac,
		DenseMatrix< Number > &	scalar_v_vel_jac,
		DenseMatrix< Number > &	scalar_p_jac
	)

protected

Compute the volumetric contributions to a velocity Jacobian.

Parameters

i_offset	The local degree of freedom offset for the velocity component
vel_gradient_j_offset	The local degree of freedom offset for the associated velocity gradient
p_j_offset	The local degree of freedom offset for the pressure
vel_component	The velocity component
u_j_offset	The local degree of freedom offset for the x-component velocity
v_j_offset	The local degree of freedom offset for the y-component velocity

Definition at line 178 of file NavierStokesLHDGAssemblyHelper.C.

{
  DiffusionLHDGAssemblyHelper::scalarVolumeJacobian(JxW, qrule, scalar_vector_jac);
 
  for (const auto i : make_range(scalar_vector_jac.m()))
    for (const auto qp : make_range(qrule.n_points()))
    {
      // Scalar equation dependence on pressure dofs
      for (const auto j : make_range(scalar_p_jac.n()))
      {
        Gradient p_phi;
        p_phi(vel_component) = _scalar_phi[j][qp];
        scalar_p_jac(i, j) -= JxW[qp] * (_grad_scalar_phi[i][qp] * p_phi);
      }
 
      // Scalar equation dependence on scalar dofs
      mooseAssert(scalar_u_vel_jac.n() == scalar_v_vel_jac.n(), "These must be the same size");
      for (const auto j : make_range(scalar_u_vel_jac.n()))
      {
        // derivatives wrt 0th component of velocity
        {
          const auto rho_vel_cross_vel =
              rhoVelCrossVelJacobian(_u_sol, _v_sol, qp, vel_component, 0, _scalar_phi, j);
          scalar_u_vel_jac(i, j) -= JxW[qp] * (_grad_scalar_phi[i][qp] * rho_vel_cross_vel);
        }
        // derivatives wrt 1th component of velocity
        {
          const auto rho_vel_cross_vel =
              rhoVelCrossVelJacobian(_u_sol, _v_sol, qp, vel_component, 1, _scalar_phi, j);
          scalar_v_vel_jac(i, j) -= JxW[qp] * (_grad_scalar_phi[i][qp] * rho_vel_cross_vel);
        }
      }
    }
}

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ scalarVolumeResidual()

void NavierStokesLHDGAssemblyHelper::scalarVolumeResidual	(	const MooseArray< Gradient > &	vel_gradient,
		const unsigned int	vel_component,
		const Moose::Functor< Real > &	body_force,
		const MooseArray< Real > &	JxW,
		const libMesh::QBase &	qrule,
		const Elem *const	current_elem,
		const MooseArray< Point > &	q_point,
		DenseVector< Number > &	scalar_re
	)

protected

Compute the volumetric contributions to a velocity residual for a provided velocity gradient and stress.

Parameters

i_offset	The local degree of freedom offset for the velocity component
vel_gradient	The velocity gradient component
vel_component	The velocity component

Definition at line 148 of file NavierStokesLHDGAssemblyHelper.C.

{
  DiffusionLHDGAssemblyHelper::scalarVolumeResidual(
      vel_gradient, body_force, JxW, qrule, current_elem, q_point, scalar_re);
 
  for (const auto qp : make_range(qrule.n_points()))
  {
    const auto rho_vel_cross_vel = rhoVelCrossVelResidual(_u_sol, _v_sol, qp, vel_component);
    Gradient qp_p;
    qp_p(vel_component) = _p_sol[qp];
 
    for (const auto i : index_range(scalar_re))
    {
      // Scalar equation dependence on pressure dofs
      scalar_re(i) -= JxW[qp] * (_grad_scalar_phi[i][qp] * qp_p);
 
      // Scalar equation dependence on scalar dofs
      scalar_re(i) -= JxW[qp] * (_grad_scalar_phi[i][qp] * rho_vel_cross_vel);
    }
  }
}

Referenced by NavierStokesLHDGKernel::computeResidual().

◆ validParams()

InputParameters NavierStokesLHDGAssemblyHelper::validParams ( )

static

Definition at line 22 of file NavierStokesLHDGAssemblyHelper.C.

{
  auto params = DiffusionLHDGAssemblyHelper::validParams();
  params.addRequiredParam<NonlinearVariableName>(NS::pressure, "The pressure variable.");
  params.addRequiredParam<NonlinearVariableName>("v", "The y-component of velocity");
  params.addParam<NonlinearVariableName>("w", "The z-component of velocity");
  params.renameParam("gradient_variable", "grad_u", "The gradient of the x-component of velocity");
  params.addRequiredParam<NonlinearVariableName>("grad_v",
                                                 "The gradient of the y-component of velocity");
  params.addParam<NonlinearVariableName>("grad_w", "The gradient of the z-component of velocity");
  params.renameParam("face_variable", "face_u", "The x-component of the face velocity");
  params.addRequiredParam<NonlinearVariableName>("face_v", "The y-component of the face velocity");
  params.addParam<NonlinearVariableName>("face_w", "The z-component of the face velocity");
  params.addParam<NonlinearVariableName>(
      "enclosure_lm",
      "For enclosed problems like the lid driven cavity this variable can be provided to remove "
      "the pressure nullspace");
  params.renameParam("diffusivity", NS::mu, "The dynamic viscosity");
  params.addRequiredParam<Real>(NS::density, "The density");
  return params;
}

Referenced by NavierStokesLHDGOutflowBC::validParams(), NavierStokesLHDGVelocityDirichletBC::validParams(), and NavierStokesLHDGKernel::validParams().

Member Data Documentation

◆ _enclosure_lm_var

const MooseVariableScalar* const NavierStokesLHDGAssemblyHelper::_enclosure_lm_var

protected

Definition at line 216 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::additionalROVariables(), NavierStokesLHDGKernel::computeJacobian(), NavierStokesLHDGKernel::computeResidual(), pressureVolumeJacobian(), and pressureVolumeResidual().

◆ _global_lm_dof_indices

const std::vector<dof_id_type>* const NavierStokesLHDGAssemblyHelper::_global_lm_dof_indices

protected

Definition at line 226 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian(), and NavierStokesLHDGKernel::computeResidual().

◆ _global_lm_dof_value

const MooseArray<Number>* const NavierStokesLHDGAssemblyHelper::_global_lm_dof_value

protected

Definition at line 236 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by pressureVolumeResidual().

◆ _global_lm_p_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_global_lm_p_jac

protected

Definition at line 245 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _global_lm_re

DenseVector<Number> NavierStokesLHDGAssemblyHelper::_global_lm_re

protected

Definition at line 242 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeResidual().

◆ _grad_u_grad_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_grad_u_grad_u_jac

protected

Definition at line 243 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _grad_u_lm_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_grad_u_lm_u_jac

protected

Definition at line 245 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _grad_u_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_grad_u_u_jac

protected

Definition at line 243 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _grad_u_vel_re

DenseVector<Number> NavierStokesLHDGAssemblyHelper::_grad_u_vel_re

protected

Definition at line 241 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _grad_v_grad_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_grad_v_grad_v_jac

protected

Definition at line 243 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _grad_v_lm_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_grad_v_lm_v_jac

protected

Definition at line 245 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _grad_v_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_grad_v_v_jac

protected

Definition at line 243 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _grad_v_var

const MooseVariableFE<RealVectorValue>& NavierStokesLHDGAssemblyHelper::_grad_v_var

protected

Definition at line 211 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::additionalROVariables(), NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), NavierStokesLHDGKernel::computeJacobianOnSide(), NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), NavierStokesLHDGKernel::computeResidualOnSide(), and NavierStokesLHDGAssemblyHelper().

◆ _grad_v_vel_re

DenseVector<Number> NavierStokesLHDGAssemblyHelper::_grad_v_vel_re

protected

Definition at line 241 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _grad_w_var

const MooseVariableFE<RealVectorValue>* const NavierStokesLHDGAssemblyHelper::_grad_w_var

protected

Definition at line 212 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGAssemblyHelper().

◆ _lm_u_grad_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_u_grad_u_jac

protected

Definition at line 246 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_u_lm_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_u_lm_u_jac

protected

Definition at line 247 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_u_lm_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_u_lm_v_jac

protected

Definition at line 248 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_u_p_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_u_p_jac

protected

Definition at line 247 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_u_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_u_u_jac

protected

Definition at line 247 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_u_vel_re

DenseVector<Number> NavierStokesLHDGAssemblyHelper::_lm_u_vel_re

protected

Definition at line 241 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _lm_v_dof_indices

const std::vector<dof_id_type>& NavierStokesLHDGAssemblyHelper::_lm_v_dof_indices

protected

Definition at line 221 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobianOnSide(), NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _lm_v_grad_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_v_grad_v_jac

protected

Definition at line 246 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_v_lm_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_v_lm_u_jac

protected

Definition at line 248 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_v_lm_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_v_lm_v_jac

protected

Definition at line 247 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_v_p_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_v_p_jac

protected

Definition at line 247 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_v_sol

const MooseArray<Number>& NavierStokesLHDGAssemblyHelper::_lm_v_sol

protected

Definition at line 231 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidualOnSide(), lmFaceJacobian(), lmFaceResidual(), pressureFaceResidual(), scalarFaceJacobian(), and scalarFaceResidual().

◆ _lm_v_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_lm_v_v_jac

protected

Definition at line 247 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _lm_v_vel_re

DenseVector<Number> NavierStokesLHDGAssemblyHelper::_lm_v_vel_re

protected

Definition at line 242 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _lm_w_dof_indices

const std::vector<dof_id_type>* const NavierStokesLHDGAssemblyHelper::_lm_w_dof_indices

protected

Definition at line 224 of file NavierStokesLHDGAssemblyHelper.h.

◆ _lm_w_sol

const MooseArray<Number>* const NavierStokesLHDGAssemblyHelper::_lm_w_sol

protected

Definition at line 234 of file NavierStokesLHDGAssemblyHelper.h.

◆ _p_dof_indices

const std::vector<dof_id_type>& NavierStokesLHDGAssemblyHelper::_p_dof_indices

protected

Definition at line 225 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), NavierStokesLHDGKernel::computeJacobianOnSide(), NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _p_global_lm_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_p_global_lm_jac

protected

Definition at line 245 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _p_lm_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_p_lm_u_jac

protected

Definition at line 248 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _p_lm_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_p_lm_v_jac

protected

Definition at line 248 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _p_re

DenseVector<Number> NavierStokesLHDGAssemblyHelper::_p_re

protected

Definition at line 242 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _p_sol

const MooseArray<Number>& NavierStokesLHDGAssemblyHelper::_p_sol

protected

Definition at line 235 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by lmFaceResidual(), pressureVolumeResidual(), scalarDirichletResidual(), scalarFaceResidual(), and scalarVolumeResidual().

◆ _p_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_p_u_jac

protected

Definition at line 245 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _p_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_p_v_jac

protected

Definition at line 245 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _pressure_var

const MooseVariableFE<Real>& NavierStokesLHDGAssemblyHelper::_pressure_var

protected

Definition at line 215 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::additionalROVariables(), NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), NavierStokesLHDGKernel::computeJacobianOnSide(), NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), NavierStokesLHDGKernel::computeResidualOnSide(), and NavierStokesLHDGAssemblyHelper().

◆ _qv_dof_indices

const std::vector<dof_id_type>& NavierStokesLHDGAssemblyHelper::_qv_dof_indices

protected

Containers for dof indices.

Definition at line 219 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), NavierStokesLHDGKernel::computeJacobianOnSide(), NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _qv_sol

const MooseArray<Gradient>& NavierStokesLHDGAssemblyHelper::_qv_sol

protected

local solutions at quadrature points

Definition at line 229 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _qw_dof_indices

const std::vector<dof_id_type>* const NavierStokesLHDGAssemblyHelper::_qw_dof_indices

protected

Definition at line 222 of file NavierStokesLHDGAssemblyHelper.h.

◆ _qw_sol

const MooseArray<Gradient>* const NavierStokesLHDGAssemblyHelper::_qw_sol

protected

Definition at line 232 of file NavierStokesLHDGAssemblyHelper.h.

◆ _rho

const Real NavierStokesLHDGAssemblyHelper::_rho

protected

The density.

Definition at line 239 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by rhoVelCrossVelJacobian(), rhoVelCrossVelResidual(), and scalarDirichletResidual().

◆ _u_grad_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_u_grad_u_jac

protected

Definition at line 244 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _u_lm_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_u_lm_u_jac

protected

Definition at line 246 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _u_lm_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_u_lm_v_jac

protected

Definition at line 246 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _u_p_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_u_p_jac

protected

Definition at line 244 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _u_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_u_u_jac

protected

Definition at line 244 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _u_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_u_v_jac

protected

Definition at line 244 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _u_vel_re

DenseVector<Number> NavierStokesLHDGAssemblyHelper::_u_vel_re

protected

Definition at line 241 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _v_dof_indices

const std::vector<dof_id_type>& NavierStokesLHDGAssemblyHelper::_v_dof_indices

protected

Definition at line 220 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), NavierStokesLHDGKernel::computeJacobianOnSide(), NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _v_face_var

const MooseVariableFE<Real>& NavierStokesLHDGAssemblyHelper::_v_face_var

protected

Definition at line 213 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::additionalROVariables(), NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobianOnSide(), NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidualOnSide(), and NavierStokesLHDGAssemblyHelper().

◆ _v_grad_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_v_grad_v_jac

protected

Definition at line 244 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _v_lm_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_v_lm_u_jac

protected

Definition at line 246 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _v_lm_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_v_lm_v_jac

protected

Definition at line 246 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _v_p_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_v_p_jac

protected

Definition at line 244 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _v_sol

const MooseArray<Number>& NavierStokesLHDGAssemblyHelper::_v_sol

protected

Definition at line 230 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), NavierStokesLHDGKernel::computeResidualOnSide(), pressureVolumeResidual(), scalarVolumeJacobian(), and scalarVolumeResidual().

◆ _v_u_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_v_u_jac

protected

Definition at line 244 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::computeJacobian().

◆ _v_v_jac

DenseMatrix<Number> NavierStokesLHDGAssemblyHelper::_v_v_jac

protected

Definition at line 244 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), and NavierStokesLHDGKernel::computeJacobianOnSide().

◆ _v_var

const MooseVariableFE<Real>& NavierStokesLHDGAssemblyHelper::_v_var

protected

Definition at line 209 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGKernel::additionalROVariables(), NavierStokesLHDGOutflowBC::computeJacobian(), NavierStokesLHDGVelocityDirichletBC::computeJacobian(), NavierStokesLHDGKernel::computeJacobian(), NavierStokesLHDGKernel::computeJacobianOnSide(), NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), NavierStokesLHDGKernel::computeResidualOnSide(), and NavierStokesLHDGAssemblyHelper().

◆ _v_vel_re

DenseVector<Number> NavierStokesLHDGAssemblyHelper::_v_vel_re

protected

Definition at line 241 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGOutflowBC::computeResidual(), NavierStokesLHDGVelocityDirichletBC::computeResidual(), NavierStokesLHDGKernel::computeResidual(), and NavierStokesLHDGKernel::computeResidualOnSide().

◆ _w_dof_indices

const std::vector<dof_id_type>* const NavierStokesLHDGAssemblyHelper::_w_dof_indices

protected

Definition at line 223 of file NavierStokesLHDGAssemblyHelper.h.

◆ _w_face_var

const MooseVariableFE<Real>* const NavierStokesLHDGAssemblyHelper::_w_face_var

protected

Definition at line 214 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGAssemblyHelper().

◆ _w_sol

const MooseArray<Number>* const NavierStokesLHDGAssemblyHelper::_w_sol

protected

Definition at line 233 of file NavierStokesLHDGAssemblyHelper.h.

◆ _w_var

const MooseVariableFE<Real>* const NavierStokesLHDGAssemblyHelper::_w_var

protected

Definition at line 210 of file NavierStokesLHDGAssemblyHelper.h.

Referenced by NavierStokesLHDGAssemblyHelper().

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

navier_stokes/include/hdgkernels/NavierStokesLHDGAssemblyHelper.h
navier_stokes/src/hdgkernels/NavierStokesLHDGAssemblyHelper.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ NavierStokesLHDGAssemblyHelper()

Member Function Documentation

◆ lmFaceJacobian()

◆ lmFaceResidual()

◆ pressureDirichletResidual()

◆ pressureFaceJacobian()

◆ pressureFaceResidual()

◆ pressureVolumeJacobian()

◆ pressureVolumeResidual()

◆ rhoVelCrossVelJacobian()

◆ rhoVelCrossVelResidual()

◆ scalarDirichletJacobian()

◆ scalarDirichletResidual()

◆ scalarFaceJacobian()

◆ scalarFaceResidual()

◆ scalarVolumeJacobian()

◆ scalarVolumeResidual()

◆ validParams()

Member Data Documentation

◆ _enclosure_lm_var

◆ _global_lm_dof_indices

◆ _global_lm_dof_value

◆ _global_lm_p_jac

◆ _global_lm_re

◆ _grad_u_grad_u_jac

◆ _grad_u_lm_u_jac

◆ _grad_u_u_jac

◆ _grad_u_vel_re

◆ _grad_v_grad_v_jac

◆ _grad_v_lm_v_jac

◆ _grad_v_v_jac

◆ _grad_v_var

◆ _grad_v_vel_re

◆ _grad_w_var

◆ _lm_u_grad_u_jac

◆ _lm_u_lm_u_jac

◆ _lm_u_lm_v_jac

◆ _lm_u_p_jac

◆ _lm_u_u_jac

◆ _lm_u_vel_re

◆ _lm_v_dof_indices

◆ _lm_v_grad_v_jac

◆ _lm_v_lm_u_jac

◆ _lm_v_lm_v_jac

◆ _lm_v_p_jac

◆ _lm_v_sol

◆ _lm_v_v_jac

◆ _lm_v_vel_re

◆ _lm_w_dof_indices

◆ _lm_w_sol

◆ _p_dof_indices

◆ _p_global_lm_jac

◆ _p_lm_u_jac

◆ _p_lm_v_jac

◆ _p_re

◆ _p_sol

◆ _p_u_jac

◆ _p_v_jac

◆ _pressure_var

◆ _qv_dof_indices

◆ _qv_sol

◆ _qw_dof_indices

◆ _qw_sol

◆ _rho

◆ _u_grad_u_jac

◆ _u_lm_u_jac

◆ _u_lm_v_jac

◆ _u_p_jac

◆ _u_u_jac

◆ _u_v_jac

◆ _u_vel_re

◆ _v_dof_indices