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

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

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

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

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

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)

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

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

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

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

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.

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

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

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

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

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

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

Referenced by NavierStokesLHDGVelocityDirichletBC::computeResidual().

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

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

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

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

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

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

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

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

Referenced by NavierStokesLHDGKernel::computeJacobian().

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

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

Referenced by NavierStokesLHDGKernel::computeResidual().

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

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

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

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

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

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

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

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

Referenced by NavierStokesLHDGVelocityDirichletBC::computeJacobian().

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

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

Referenced by NavierStokesLHDGVelocityDirichletBC::computeResidual().

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

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

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

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

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

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

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

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

Referenced by NavierStokesLHDGKernel::computeJacobian().

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

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

Referenced by NavierStokesLHDGKernel::computeResidual().

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

◆ validParams()

InputParameters NavierStokesLHDGAssemblyHelper::validParams ( )

static

Definition at line 22 of file NavierStokesLHDGAssemblyHelper.C.

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

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