#include <hdg_problem.h>

Inheritance diagram for libMesh::HDGProblem:

Public Member Functions
	HDGProblem (const Real nu_in, const bool cavity_in)

	~HDGProblem ()

void	init ()

virtual void	residual (const NumericVector< Number > &X, NumericVector< Number > &R, NonlinearImplicitSystem &S) override

virtual void	jacobian (const NumericVector< Number > &X, SparseMatrix< Number > &, NonlinearImplicitSystem &S) override

virtual void	residual (const NumericVector< Number > &X, NumericVector< Number > &R, sys_type &S)=0
	Residual function. More...

virtual void	jacobian (const NumericVector< Number > &X, SparseMatrix< Number > &J, sys_type &S)=0
	Jacobian function. More...

Public Attributes
System *	system

const MeshBase *	mesh

const DofMap *	dof_map

StaticCondensation *	sc

std::unique_ptr< FEVectorBase >	vector_fe

std::unique_ptr< FEBase >	scalar_fe

std::unique_ptr< QBase >	qrule

std::unique_ptr< FEVectorBase >	vector_fe_face

std::unique_ptr< FEBase >	scalar_fe_face

std::unique_ptr< FEBase >	lm_fe_face

std::unique_ptr< QBase >	qface

boundary_id_type	left_bnd

boundary_id_type	top_bnd

boundary_id_type	right_bnd

boundary_id_type	bottom_bnd

Real	nu

bool	cavity

const USoln	u_true_soln

const VSoln	v_true_soln

const PSoln	p_true_soln

bool	mms

Private Member Functions
void	add_matrix (NonlinearImplicitSystem &sys, const unsigned int ivar_num, const unsigned int jvar_num, const DenseMatrix< Number > &elem_mat)

void	create_identity_residual (const QBase &quadrature, const std::vector< Real > &JxW_local, const std::vector< std::vector< Real >> &phi, const std::vector< Number > &sol, const std::size_t n_dofs, DenseVector< Number > &R)

void	create_identity_jacobian (const QBase &quadrature, const std::vector< Real > &JxW_local, const std::vector< std::vector< Real >> &phi, const std::size_t n_dofs, DenseMatrix< Number > &J)

void	compute_stress (const std::vector< Gradient > &vel_gradient, const unsigned int vel_component, std::vector< Gradient > &sigma)

void	vector_volume_residual (const std::vector< Gradient > &vector_sol, const std::vector< Number > &scalar_sol, DenseVector< Number > &R)

void	vector_volume_jacobian (DenseMatrix< Number > &Jqq, DenseMatrix< Number > &Jqs)

NumberVectorValue	vel_cross_vel_residual (const std::vector< Number > &u_sol_local, const std::vector< Number > &v_sol_local, const unsigned int qp, const unsigned int vel_component) const

NumberVectorValue	vel_cross_vel_jacobian (const std::vector< Number > &u_sol_local, const std::vector< Number > &v_sol_local, const unsigned int qp, const unsigned int vel_component, const unsigned int vel_j_component, const std::vector< std::vector< Real >> &phi, const unsigned int j) const

void	scalar_volume_residual (const std::vector< Gradient > &vel_gradient, const unsigned int vel_component, std::vector< Gradient > &sigma, DenseVector< Number > &R)

void	scalar_volume_jacobian (const unsigned int vel_component, DenseMatrix< Number > &Jsq, DenseMatrix< Number > &Jsp, DenseMatrix< Number > &Jsu, DenseMatrix< Number > &Jsv)

void	pressure_volume_residual (DenseVector< Number > &Rp, DenseVector< Number > &Rglm)

void	pressure_volume_jacobian (DenseMatrix< Number > &Jpu, DenseMatrix< Number > &Jpv, DenseMatrix< Number > &Jpglm, DenseMatrix< Number > &Jglmp)

void	pressure_face_residual (DenseVector< Number > &R)

void	pressure_face_jacobian (DenseMatrix< Number > &Jplm_u, DenseMatrix< Number > &Jplm_v)

RealVectorValue	get_dirichlet_velocity (const unsigned int qp) const

void	pressure_dirichlet_residual (DenseVector< Number > &R)

void	vector_dirichlet_residual (const unsigned int vel_component, DenseVector< Number > &R)

void	vector_face_residual (const std::vector< Number > &lm_sol, DenseVector< Number > &R)

void	vector_face_jacobian (DenseMatrix< Number > &Jqlm)

void	scalar_dirichlet_residual (const std::vector< Gradient > &vector_sol, const std::vector< Number > &scalar_sol, const unsigned int vel_component, DenseVector< Number > &R)

void	scalar_dirichlet_jacobian (const unsigned int vel_component, DenseMatrix< Number > &Jsq, DenseMatrix< Number > &Jsp, DenseMatrix< Number > &Jss)

void	scalar_face_residual (const std::vector< Gradient > &vector_sol, const std::vector< Number > &scalar_sol, const std::vector< Number > &lm_sol, const unsigned int vel_component, DenseVector< Number > &R)

void	scalar_face_jacobian (const unsigned int vel_component, DenseMatrix< Number > &Jsq, DenseMatrix< Number > &Jsp, DenseMatrix< Number > &Jss, DenseMatrix< Number > &Jslm, DenseMatrix< Number > &Js_lmu, DenseMatrix< Number > &Js_lmv)

void	lm_face_residual (const std::vector< Gradient > &vector_sol, const std::vector< Number > &scalar_sol, const std::vector< Number > &lm_sol, const unsigned int vel_component, DenseVector< Number > &R)

void	lm_face_jacobian (const unsigned int vel_component, DenseMatrix< Number > &Jlmq, DenseMatrix< Number > &Jlmp, DenseMatrix< Number > &Jlms, DenseMatrix< Number > &Jlmlm, DenseMatrix< Number > &Jlm_lmu, DenseMatrix< Number > &Jlm_lmv)

Private Attributes
const std::vector< Real > *	JxW

const std::vector< Point > *	q_point

const std::vector< std::vector< RealVectorValue > > *	vector_phi

const std::vector< std::vector< Real > > *	scalar_phi

const std::vector< std::vector< RealVectorValue > > *	grad_scalar_phi

const std::vector< std::vector< Real > > *	div_vector_phi

const std::vector< Real > *	JxW_face

const std::vector< Point > *	qface_point

const std::vector< std::vector< RealVectorValue > > *	vector_phi_face

const std::vector< std::vector< Real > > *	scalar_phi_face

const std::vector< std::vector< Real > > *	lm_phi_face

const std::vector< Point > *	normals

std::unordered_map< unsigned int, std::vector< dof_id_type > >	dof_indices

std::vector< Gradient >	qu_sol

std::vector< Number >	u_sol

std::vector< Number >	lm_u_sol

std::vector< Gradient >	qv_sol

std::vector< Number >	v_sol

std::vector< Number >	lm_v_sol

std::vector< Number >	p_sol

std::vector< Gradient >	sigma_u

std::vector< Gradient >	sigma_v

std::vector< Number >	qu_dof_values

std::vector< Number >	u_dof_values

std::vector< Number >	lm_u_dof_values

std::vector< Number >	qv_dof_values

std::vector< Number >	v_dof_values

std::vector< Number >	lm_v_dof_values

std::vector< Number >	p_dof_values

Number	global_lm_dof_value

std::size_t	vector_n_dofs

std::size_t	scalar_n_dofs

std::size_t	lm_n_dofs

std::size_t	p_n_dofs

std::size_t	global_lm_n_dofs

boundary_id_type	current_bnd

const Elem *	neigh

std::vector< Number >	qbar

Static Private Attributes
static constexpr Real	tau = 1

Detailed Description

Definition at line 34 of file hdg_problem.h.

Constructor & Destructor Documentation

◆ HDGProblem()

libMesh::HDGProblem::HDGProblem	(	const Real	nu_in,
		const bool	cavity_in
	)

Definition at line 53 of file hdg_problem.C.

   : nu(nu_in),
     cavity(cavity_in),
     u_true_soln(nu, cavity),
     v_true_soln(nu, cavity),
     p_true_soln(cavity)
 {
 }

◆ ~HDGProblem()

libMesh::HDGProblem::~HDGProblem ( )

default

Member Function Documentation

◆ add_matrix()

void libMesh::HDGProblem::add_matrix	(	NonlinearImplicitSystem &	sys,
		const unsigned int	ivar_num,
		const unsigned int	jvar_num,
		const DenseMatrix< Number > &	elem_mat
	)

private

Definition at line 886 of file hdg_problem.C.

References libMesh::SparseMatrix< T >::add_matrix(), dof_indices, and libMesh::ImplicitSystem::get_system_matrix().

Referenced by jacobian().

 {
   sys.get_system_matrix().add_matrix(
       elem_mat, libmesh_map_find(dof_indices, ivar_num), libmesh_map_find(dof_indices, jvar_num));
 }

◆ compute_stress()

void libMesh::HDGProblem::compute_stress	(	const std::vector< Gradient > &	vel_gradient,
		const unsigned int	vel_component,
		std::vector< Gradient > &	sigma
	)

private

Definition at line 131 of file hdg_problem.C.

References libMesh::make_range(), nu, p_sol, and qrule.

Referenced by scalar_volume_residual().

 {
   sigma.resize(qrule->n_points());
   for (const auto qp : make_range(qrule->n_points()))
   {
     Gradient qp_p;
     qp_p(vel_component) = p_sol[qp];
     sigma[qp] = nu * vel_gradient[qp] - qp_p;
   }
 }

◆ create_identity_jacobian()

void libMesh::HDGProblem::create_identity_jacobian	(	const QBase &	quadrature,
		const std::vector< Real > &	JxW_local,
		const std::vector< std::vector< Real >> &	phi,
		const std::size_t	n_dofs,
		DenseMatrix< Number > &	J
	)

private

Definition at line 118 of file hdg_problem.C.

References libMesh::make_range(), and libMesh::QBase::n_points().

Referenced by jacobian().

 {
   for (const auto qp : make_range(quadrature.n_points()))
     for (const auto i : make_range(n_dofs))
       for (const auto j : make_range(n_dofs))
         J(i, j) -= JxW_local[qp] * phi[i][qp] * phi[j][qp];
 }

◆ create_identity_residual()

void libMesh::HDGProblem::create_identity_residual	(	const QBase &	quadrature,
		const std::vector< Real > &	JxW_local,
		const std::vector< std::vector< Real >> &	phi,
		const std::vector< Number > &	sol,
		const std::size_t	n_dofs,
		DenseVector< Number > &	R
	)

private

Definition at line 105 of file hdg_problem.C.

References libMesh::make_range(), and libMesh::QBase::n_points().

Referenced by residual().

 {
   for (const auto qp : make_range(quadrature.n_points()))
     for (const auto i : make_range(n_dofs))
       R(i) -= JxW_local[qp] * phi[i][qp] * sol[qp];
 }

◆ get_dirichlet_velocity()

RealVectorValue libMesh::HDGProblem::get_dirichlet_velocity ( const unsigned int qp ) const

private

Definition at line 371 of file hdg_problem.C.

References cavity, current_bnd, left_bnd, libMesh::libmesh_assert(), mms, qface_point, right_bnd, top_bnd, u_true_soln, and v_true_soln.

Referenced by pressure_dirichlet_residual(), scalar_dirichlet_residual(), and vector_dirichlet_residual().

 {
   if (mms)
     return RealVectorValue(u_true_soln((*qface_point)[qp]), v_true_soln((*qface_point)[qp]));
 
   if (cavity)
   {
     if (current_bnd == top_bnd)
       return RealVectorValue(1, 0);
     else
       return RealVectorValue(0, 0);
   }
   else // channel flow case
   {
     libmesh_assert(current_bnd != right_bnd);
 
     if (current_bnd == left_bnd)
       return RealVectorValue(1, 0);
 
     else
       return RealVectorValue(0, 0);
   }
 }

◆ init()

void libMesh::HDGProblem::init ( )

Definition at line 65 of file hdg_problem.C.

References bottom_bnd, cavity, div_vector_phi, libMesh::MeshBase::get_boundary_info(), global_lm_n_dofs, grad_scalar_phi, libMesh::BoundaryInfo::invalid_id, JxW, JxW_face, left_bnd, libMesh::libmesh_assert(), lm_fe_face, lm_phi_face, mesh, normals, q_point, qface, qface_point, qrule, right_bnd, scalar_fe, scalar_fe_face, scalar_phi, scalar_phi_face, top_bnd, vector_fe, vector_fe_face, vector_phi, and vector_phi_face.

Referenced by main().

 {
   // Attach quadrature rules for the FE objects that we will reinit within the element "volume"
   vector_fe->attach_quadrature_rule(qrule.get());
   scalar_fe->attach_quadrature_rule(qrule.get());
 
   // Attach quadrature rules for the FE objects that we will reinit on the element faces
   vector_fe_face->attach_quadrature_rule(qface.get());
   scalar_fe_face->attach_quadrature_rule(qface.get());
   lm_fe_face->attach_quadrature_rule(qface.get());
 
   // pre-request our required volumetric data
   JxW = &vector_fe->get_JxW();
   q_point = &vector_fe->get_xyz();
   vector_phi = &vector_fe->get_phi();
   scalar_phi = &scalar_fe->get_phi();
   grad_scalar_phi = &scalar_fe->get_dphi();
   div_vector_phi = &vector_fe->get_div_phi();
 
   // pre-request our required element face data
   vector_phi_face = &vector_fe_face->get_phi();
   scalar_phi_face = &scalar_fe_face->get_phi();
   lm_phi_face = &lm_fe_face->get_phi();
   JxW_face = &vector_fe_face->get_JxW();
   qface_point = &vector_fe_face->get_xyz();
   normals = &vector_fe_face->get_normals();
 
   const auto & bnd_info = mesh->get_boundary_info();
   left_bnd = bnd_info.get_id_by_name("left");
   top_bnd = bnd_info.get_id_by_name("top");
   right_bnd = bnd_info.get_id_by_name("right");
   bottom_bnd = bnd_info.get_id_by_name("bottom");
   libmesh_assert(left_bnd != BoundaryInfo::invalid_id);
   libmesh_assert(top_bnd != BoundaryInfo::invalid_id);
   libmesh_assert(right_bnd != BoundaryInfo::invalid_id);
   libmesh_assert(bottom_bnd != BoundaryInfo::invalid_id);
   global_lm_n_dofs = cavity ? 1 : 0;
 }

◆ jacobian() [1/2]

void libMesh::HDGProblem::jacobian	(	const NumericVector< Number > &	X,
		SparseMatrix< Number > &	,
		NonlinearImplicitSystem &	S
	)

overridevirtual

Definition at line 896 of file hdg_problem.C.

References libMesh::SparseMatrix< T >::add(), add_matrix(), cavity, libMesh::compute_qp_soln(), create_identity_jacobian(), current_bnd, dof_indices, libMesh::DofMap::dof_indices(), dof_map, libMesh::NumericVector< T >::get(), libMesh::MeshBase::get_boundary_info(), libMesh::ImplicitSystem::get_system_matrix(), global_lm_dof_value, libMesh::invalid_uint, JxW_face, libMesh::libmesh_assert(), lm_face_jacobian(), lm_fe_face, lm_n_dofs, lm_phi_face, lm_u_dof_values, lm_u_sol, lm_v_dof_values, lm_v_sol, libMesh::make_range(), mesh, neigh, libMesh::Elem::neighbor_ptr(), p_dof_values, p_n_dofs, p_sol, pressure_face_jacobian(), pressure_volume_jacobian(), qface, qrule, qu_dof_values, qu_sol, qv_dof_values, qv_sol, libMesh::DenseMatrix< T >::resize(), right_bnd, sc, scalar_dirichlet_jacobian(), scalar_face_jacobian(), scalar_fe, scalar_fe_face, scalar_n_dofs, scalar_phi, scalar_phi_face, scalar_volume_jacobian(), libMesh::StaticCondensation::set_current_elem(), u_dof_values, u_sol, v_dof_values, v_sol, libMesh::System::variable_number(), vector_face_jacobian(), vector_fe, vector_fe_face, vector_n_dofs, vector_phi, vector_phi_face, and vector_volume_jacobian().

 {
   auto * J = &S.get_system_matrix();
 
   if (!sc)
     // PETSc requires that the Jacobian matrix have a diagonal for some types of preconditioners
     for (const auto i : make_range(J->row_start(), J->row_stop()))
       J->add(i, i, 0);
 
   const auto u_num = S.variable_number("vel_x");
   const auto v_num = S.variable_number("vel_y");
   const auto qu_num = S.variable_number("qu");
   const auto qv_num = S.variable_number("qv");
   const auto lm_u_num = S.variable_number("lm_u");
   const auto lm_v_num = S.variable_number("lm_v");
   const auto p_num = S.variable_number("pressure");
   const auto global_lm_num = cavity ? S.variable_number("global_lm") : invalid_uint;
 
   auto & qu_dof_indices = dof_indices[qu_num];
   auto & u_dof_indices = dof_indices[u_num];
   auto & lm_u_dof_indices = dof_indices[lm_u_num];
   auto & qv_dof_indices = dof_indices[qv_num];
   auto & v_dof_indices = dof_indices[v_num];
   auto & lm_v_dof_indices = dof_indices[lm_v_num];
   auto & p_dof_indices = dof_indices[p_num];
   static std::vector<dof_id_type> dummy_indices;
   auto & global_lm_dof_indices = cavity ? dof_indices[global_lm_num] : dummy_indices;
 
   std::vector<boundary_id_type> boundary_ids;
   const auto & boundary_info = mesh->get_boundary_info();
 
   DenseMatrix<Number> Jqu_qu, Jqv_qv, Jqu_u, Jqv_v, Ju_qu, Jv_qv, Ju_p, Jv_p, Ju_u, Jv_u, Ju_v,
       Jv_v, Jp_u, Jp_v, Jp_glm, Jglm_p, Jp_lmu, Jp_lmv, Jqu_lmu, Jqv_lmv, Ju_lmu, Jv_lmv, Jv_lmu,
       Ju_lmv, Jlmu_qu, Jlmv_qv, Jlmu_p, Jlmv_p, Jlmu_u, Jlmv_v, Jlmu_lmu, Jlmv_lmu, Jlmu_lmv,
       Jlmv_lmv;
 
   for (const auto & elem : mesh->active_local_element_ptr_range())
   {
     if (sc)
       sc->set_current_elem(*elem);
 
     // Retrive our dof indices for all fields
     dof_map->dof_indices(elem, qu_dof_indices, qu_num);
     dof_map->dof_indices(elem, u_dof_indices, u_num);
     dof_map->dof_indices(elem, lm_u_dof_indices, lm_u_num);
     dof_map->dof_indices(elem, qv_dof_indices, qv_num);
     dof_map->dof_indices(elem, v_dof_indices, v_num);
     dof_map->dof_indices(elem, lm_v_dof_indices, lm_v_num);
     dof_map->dof_indices(elem, p_dof_indices, p_num);
     if (cavity)
     {
       dof_map->dof_indices(elem, global_lm_dof_indices, global_lm_num);
       libmesh_assert(global_lm_dof_indices.size() == 1);
     }
 
     vector_n_dofs = qu_dof_indices.size();
     scalar_n_dofs = u_dof_indices.size();
     lm_n_dofs = lm_u_dof_indices.size();
     p_n_dofs = p_dof_indices.size();
     libmesh_assert(p_n_dofs == scalar_n_dofs);
 
     Jqu_qu.resize(qu_dof_indices.size(), qu_dof_indices.size());
     Jqv_qv.resize(qv_dof_indices.size(), qv_dof_indices.size());
     Jqu_u.resize(qu_dof_indices.size(), u_dof_indices.size());
     Jqv_v.resize(qv_dof_indices.size(), v_dof_indices.size());
     Ju_qu.resize(u_dof_indices.size(), qu_dof_indices.size());
     Jv_qv.resize(v_dof_indices.size(), qv_dof_indices.size());
     Ju_p.resize(u_dof_indices.size(), p_dof_indices.size());
     Jv_p.resize(v_dof_indices.size(), p_dof_indices.size());
     Ju_u.resize(u_dof_indices.size(), u_dof_indices.size());
     Jv_u.resize(v_dof_indices.size(), u_dof_indices.size());
     Ju_v.resize(u_dof_indices.size(), v_dof_indices.size());
     Jv_v.resize(v_dof_indices.size(), v_dof_indices.size());
     Jp_u.resize(p_dof_indices.size(), u_dof_indices.size());
     Jp_v.resize(p_dof_indices.size(), v_dof_indices.size());
     Jp_glm.resize(p_dof_indices.size(), global_lm_dof_indices.size());
     Jglm_p.resize(global_lm_dof_indices.size(), p_dof_indices.size());
     Jp_lmu.resize(p_dof_indices.size(), lm_u_dof_indices.size());
     Jp_lmv.resize(p_dof_indices.size(), lm_v_dof_indices.size());
     Jqu_lmu.resize(qu_dof_indices.size(), lm_u_dof_indices.size());
     Jqv_lmv.resize(qv_dof_indices.size(), lm_v_dof_indices.size());
     Ju_lmu.resize(u_dof_indices.size(), lm_u_dof_indices.size());
     Jv_lmv.resize(v_dof_indices.size(), lm_v_dof_indices.size());
     Jv_lmu.resize(v_dof_indices.size(), lm_u_dof_indices.size());
     Ju_lmv.resize(u_dof_indices.size(), lm_v_dof_indices.size());
     Jlmu_qu.resize(lm_u_dof_indices.size(), qu_dof_indices.size());
     Jlmv_qv.resize(lm_v_dof_indices.size(), qv_dof_indices.size());
     Jlmu_p.resize(lm_u_dof_indices.size(), p_dof_indices.size());
     Jlmv_p.resize(lm_v_dof_indices.size(), p_dof_indices.size());
     Jlmu_u.resize(lm_u_dof_indices.size(), u_dof_indices.size());
     Jlmv_v.resize(lm_v_dof_indices.size(), v_dof_indices.size());
     Jlmu_lmu.resize(lm_u_dof_indices.size(), lm_u_dof_indices.size());
     Jlmv_lmu.resize(lm_v_dof_indices.size(), lm_u_dof_indices.size());
     Jlmu_lmv.resize(lm_u_dof_indices.size(), lm_v_dof_indices.size());
     Jlmv_lmv.resize(lm_v_dof_indices.size(), lm_v_dof_indices.size());
 
     // Reinit our volume FE objects
     vector_fe->reinit(elem);
     scalar_fe->reinit(elem);
 
     libmesh_assert_equal_to(vector_n_dofs, vector_phi->size());
     libmesh_assert_equal_to(scalar_n_dofs, scalar_phi->size());
 
     // Get our local element dof values
     X.get(qu_dof_indices, qu_dof_values);
     X.get(u_dof_indices, u_dof_values);
     X.get(lm_u_dof_indices, lm_u_dof_values);
     X.get(qv_dof_indices, qv_dof_values);
     X.get(v_dof_indices, v_dof_values);
     X.get(lm_v_dof_indices, lm_v_dof_values);
     X.get(p_dof_indices, p_dof_values);
     if (cavity)
       global_lm_dof_value = X(global_lm_dof_indices[0]);
 
     // Compute volumetric local qp solutions
     compute_qp_soln(qu_sol, qrule->n_points(), *vector_phi, qu_dof_values);
     compute_qp_soln(u_sol, qrule->n_points(), *scalar_phi, u_dof_values);
     compute_qp_soln(qv_sol, qrule->n_points(), *vector_phi, qv_dof_values);
     compute_qp_soln(v_sol, qrule->n_points(), *scalar_phi, v_dof_values);
     compute_qp_soln(p_sol, qrule->n_points(), *scalar_phi, p_dof_values);
 
     //
     // compute volumetric residuals and Jacobians
     //
 
     // qu and u
     vector_volume_jacobian(Jqu_qu, Jqu_u);
     scalar_volume_jacobian(0, Ju_qu, Ju_p, Ju_u, Ju_v);
 
     // qv and v
     vector_volume_jacobian(Jqv_qv, Jqv_v);
     scalar_volume_jacobian(1, Jv_qv, Jv_p, Jv_u, Jv_v);
 
     // p
     pressure_volume_jacobian(Jp_u, Jp_v, Jp_glm, Jglm_p);
 
     for (auto side : elem->side_index_range())
     {
       neigh = elem->neighbor_ptr(side);
 
       // Reinit our face FE objects
       vector_fe_face->reinit(elem, side);
       scalar_fe_face->reinit(elem, side);
       lm_fe_face->reinit(elem, side);
 
       // Compute face local qp solutions
       compute_qp_soln(qu_sol, qface->n_points(), *vector_phi_face, qu_dof_values);
       compute_qp_soln(u_sol, qface->n_points(), *scalar_phi_face, u_dof_values);
       compute_qp_soln(lm_u_sol, qface->n_points(), *lm_phi_face, lm_u_dof_values);
       compute_qp_soln(qv_sol, qface->n_points(), *vector_phi_face, qv_dof_values);
       compute_qp_soln(v_sol, qface->n_points(), *scalar_phi_face, v_dof_values);
       compute_qp_soln(lm_v_sol, qface->n_points(), *lm_phi_face, lm_v_dof_values);
       compute_qp_soln(p_sol, qface->n_points(), *scalar_phi_face, p_dof_values);
 
       if (neigh == nullptr)
       {
         boundary_info.boundary_ids(elem, side, boundary_ids);
         libmesh_assert(boundary_ids.size() == 1);
         current_bnd = boundary_ids[0];
         if (cavity || (current_bnd != right_bnd))
         {
           // qu, u
           scalar_dirichlet_jacobian(0, Ju_qu, Ju_p, Ju_u);
 
           // qv, v
           scalar_dirichlet_jacobian(1, Jv_qv, Jv_p, Jv_v);
 
           // Set the LMs on these Dirichlet boundary faces to 0
           create_identity_jacobian(*qface, *JxW_face, *lm_phi_face, lm_n_dofs, Jlmu_lmu);
           create_identity_jacobian(*qface, *JxW_face, *lm_phi_face, lm_n_dofs, Jlmv_lmv);
 
           continue;
         }
       }
 
       //
       // if we got here, then we are on an internal face or an outlet face
       //
 
       // qu, u, lm_u
       vector_face_jacobian(Jqu_lmu);
       scalar_face_jacobian(0, Ju_qu, Ju_p, Ju_u, Ju_lmu, Ju_lmu, Ju_lmv);
       lm_face_jacobian(0, Jlmu_qu, Jlmu_p, Jlmu_u, Jlmu_lmu, Jlmu_lmu, Jlmu_lmv);
 
       // qv, v, lm_v
       vector_face_jacobian(Jqv_lmv);
       scalar_face_jacobian(1, Jv_qv, Jv_p, Jv_v, Jv_lmv, Jv_lmu, Jv_lmv);
       lm_face_jacobian(1, Jlmv_qv, Jlmv_p, Jlmv_v, Jlmv_lmv, Jlmv_lmu, Jlmv_lmv);
 
       // p
       pressure_face_jacobian(Jp_lmu, Jp_lmv);
     }
 
     add_matrix(S, qu_num, qu_num, Jqu_qu);
     add_matrix(S, qv_num, qv_num, Jqv_qv);
     add_matrix(S, qu_num, u_num, Jqu_u);
     add_matrix(S, qv_num, v_num, Jqv_v);
     add_matrix(S, u_num, qu_num, Ju_qu);
     add_matrix(S, v_num, qv_num, Jv_qv);
     add_matrix(S, u_num, p_num, Ju_p);
     add_matrix(S, v_num, p_num, Jv_p);
     add_matrix(S, u_num, u_num, Ju_u);
     add_matrix(S, v_num, u_num, Jv_u);
     add_matrix(S, u_num, v_num, Ju_v);
     add_matrix(S, v_num, v_num, Jv_v);
     add_matrix(S, p_num, u_num, Jp_u);
     add_matrix(S, p_num, v_num, Jp_v);
     if (global_lm_num != invalid_uint)
     {
       add_matrix(S, p_num, global_lm_num, Jp_glm);
       add_matrix(S, global_lm_num, p_num, Jglm_p);
     }
     add_matrix(S, p_num, lm_u_num, Jp_lmu);
     add_matrix(S, p_num, lm_v_num, Jp_lmv);
     add_matrix(S, qu_num, lm_u_num, Jqu_lmu);
     add_matrix(S, qv_num, lm_v_num, Jqv_lmv);
     add_matrix(S, u_num, lm_u_num, Ju_lmu);
     add_matrix(S, v_num, lm_v_num, Jv_lmv);
     add_matrix(S, v_num, lm_u_num, Jv_lmu);
     add_matrix(S, u_num, lm_v_num, Ju_lmv);
     add_matrix(S, lm_u_num, qu_num, Jlmu_qu);
     add_matrix(S, lm_v_num, qv_num, Jlmv_qv);
     add_matrix(S, lm_u_num, p_num, Jlmu_p);
     add_matrix(S, lm_v_num, p_num, Jlmv_p);
     add_matrix(S, lm_u_num, u_num, Jlmu_u);
     add_matrix(S, lm_v_num, v_num, Jlmv_v);
     add_matrix(S, lm_u_num, lm_u_num, Jlmu_lmu);
     add_matrix(S, lm_v_num, lm_u_num, Jlmv_lmu);
     add_matrix(S, lm_u_num, lm_v_num, Jlmu_lmv);
     add_matrix(S, lm_v_num, lm_v_num, Jlmv_lmv);
   }
 
   J->close();
 }

◆ jacobian() [2/2]

virtual void libMesh::NonlinearImplicitSystem::ComputeJacobian::jacobian	(	const NumericVector< Number > &	X,
		SparseMatrix< Number > &	J,
		sys_type &	S
	)

pure virtualinherited

Jacobian function.

This function will be called to compute the jacobian and must be implemented by the user in a derived class.

Referenced by libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), and libMesh::libmesh_petsc_snes_jacobian().

◆ lm_face_jacobian()

void libMesh::HDGProblem::lm_face_jacobian	(	const unsigned int	vel_component,
		DenseMatrix< Number > &	Jlmq,
		DenseMatrix< Number > &	Jlmp,
		DenseMatrix< Number > &	Jlms,
		DenseMatrix< Number > &	Jlmlm,
		DenseMatrix< Number > &	Jlm_lmu,
		DenseMatrix< Number > &	Jlm_lmv
	)

private

Definition at line 655 of file hdg_problem.C.

References current_bnd, lm_n_dofs, lm_phi_face, lm_u_sol, lm_v_sol, libMesh::make_range(), neigh, nu, p_n_dofs, qface, right_bnd, scalar_n_dofs, tau, vector_n_dofs, and vel_cross_vel_jacobian().

Referenced by jacobian().

 {
   for (const auto qp : make_range(qface->n_points()))
     for (const auto i : make_range(lm_n_dofs))
     {
       for (const auto j : make_range(vector_n_dofs))
         Jlmq(i, j) -= (*JxW_face)[qp] * nu * (*lm_phi_face)[i][qp] *
                       ((*vector_phi_face)[j][qp] * (*normals)[qp]);
 
       for (const auto j : make_range(p_n_dofs))
       {
         Gradient p_phi;
         p_phi(vel_component) = (*scalar_phi_face)[j][qp];
         Jlmp(i, j) += (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * (p_phi * (*normals)[qp]);
       }
 
       for (const auto j : make_range(scalar_n_dofs))
         Jlms(i, j) += (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * tau * (*scalar_phi_face)[j][qp] *
                       (*normals)[qp] * (*normals)[qp];
 
       for (const auto j : make_range(lm_n_dofs))
       {
         // from stabilization term
         Jlmlm(i, j) -= (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * tau * (*lm_phi_face)[j][qp] *
                        (*normals)[qp] * (*normals)[qp];
         if (neigh)
         {
           // derivatives wrt 0th component
           {
             const auto vel_cross_vel =
                 vel_cross_vel_jacobian(lm_u_sol, lm_v_sol, qp, vel_component, 0, (*lm_phi_face), j);
             Jlm_lmu(i, j) +=
                 (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * vel_cross_vel * (*normals)[qp];
           }
           // derivatives wrt 1th component
           {
             const auto vel_cross_vel =
                 vel_cross_vel_jacobian(lm_u_sol, lm_v_sol, qp, vel_component, 1, (*lm_phi_face), j);
             Jlm_lmv(i, j) +=
                 (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * vel_cross_vel * (*normals)[qp];
           }
         }
         else
           libmesh_assert_msg(current_bnd == right_bnd,
                              "This method should only be called with an outflow boundary. "
                              "Dirichlet boundaries should call a different routine");
       }
     }
 }

◆ lm_face_residual()

void libMesh::HDGProblem::lm_face_residual	(	const std::vector< Gradient > &	vector_sol,
		const std::vector< Number > &	scalar_sol,
		const std::vector< Number > &	lm_sol,
		const unsigned int	vel_component,
		DenseVector< Number > &	R
	)

private

Definition at line 613 of file hdg_problem.C.

References current_bnd, lm_n_dofs, lm_u_sol, lm_v_sol, libMesh::make_range(), neigh, nu, p_sol, qface, right_bnd, tau, and vel_cross_vel_residual().

Referenced by residual().

 {
   for (const auto qp : make_range(qface->n_points()))
   {
     Gradient qp_p;
     qp_p(vel_component) = p_sol[qp];
     const auto vel_cross_vel = vel_cross_vel_residual(lm_u_sol, lm_v_sol, qp, vel_component);
 
     for (const auto i : make_range(lm_n_dofs))
     {
       // vector
       R(i) -= (*JxW_face)[qp] * nu * (*lm_phi_face)[i][qp] * (vector_sol[qp] * (*normals)[qp]);
 
       // pressure
       R(i) += (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * (qp_p * (*normals)[qp]);
 
       // scalar from stabilization term
       R(i) += (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * tau * scalar_sol[qp] * (*normals)[qp] *
               (*normals)[qp];
 
       // lm from stabilization term
       R(i) -= (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * tau * lm_sol[qp] * (*normals)[qp] *
               (*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
         R(i) += (*JxW_face)[qp] * (*lm_phi_face)[i][qp] * vel_cross_vel * (*normals)[qp];
       else
         libmesh_assert_msg(current_bnd == right_bnd,
                            "This method should only be called with an outflow boundary. "
                            "Dirichlet boundaries should call a different routine");
     }
   }
 }

◆ pressure_dirichlet_residual()

void libMesh::HDGProblem::pressure_dirichlet_residual ( DenseVector< Number > & R )

private

Definition at line 396 of file hdg_problem.C.

References get_dirichlet_velocity(), libMesh::make_range(), p_n_dofs, and qface.

Referenced by residual().

 {
   for (const auto qp : make_range(qface->n_points()))
   {
     const auto dirichlet_velocity = get_dirichlet_velocity(qp);
     const auto vdotn = dirichlet_velocity * (*normals)[qp];
     for (const auto i : make_range(p_n_dofs))
       R(i) += (*JxW_face)[qp] * vdotn * (*scalar_phi_face)[i][qp];
   }
 }

◆ pressure_face_jacobian()

void libMesh::HDGProblem::pressure_face_jacobian	(	DenseMatrix< Number > &	Jplm_u,
		DenseMatrix< Number > &	Jplm_v
	)

private

Definition at line 353 of file hdg_problem.C.

References lm_n_dofs, lm_phi_face, libMesh::make_range(), p_n_dofs, and qface.

Referenced by jacobian().

 {
   for (const auto qp : make_range(qface->n_points()))
     for (const auto i : make_range(p_n_dofs))
       for (const auto j : make_range(lm_n_dofs))
       {
         {
           const Gradient phi((*lm_phi_face)[j][qp], Number(0));
           Jplm_u(i, j) += (*JxW_face)[qp] * phi * (*normals)[qp] * (*scalar_phi_face)[i][qp];
         }
         {
           const Gradient phi(Number(0), (*lm_phi_face)[j][qp]);
           Jplm_v(i, j) += (*JxW_face)[qp] * phi * (*normals)[qp] * (*scalar_phi_face)[i][qp];
         }
       }
 }

◆ pressure_face_residual()

void libMesh::HDGProblem::pressure_face_residual ( DenseVector< Number > & R )

private

Definition at line 341 of file hdg_problem.C.

References lm_u_sol, lm_v_sol, libMesh::make_range(), p_n_dofs, and qface.

Referenced by residual().

 {
   for (const auto qp : make_range(qface->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(p_n_dofs))
       R(i) += (*JxW_face)[qp] * vdotn * (*scalar_phi_face)[i][qp];
   }
 }

◆ pressure_volume_jacobian()

void libMesh::HDGProblem::pressure_volume_jacobian	(	DenseMatrix< Number > &	Jpu,
		DenseMatrix< Number > &	Jpv,
		DenseMatrix< Number > &	Jpglm,
		DenseMatrix< Number > &	Jglmp
	)

private

Definition at line 307 of file hdg_problem.C.

References cavity, libMesh::libmesh_assert(), libMesh::make_range(), p_n_dofs, qrule, scalar_n_dofs, and scalar_phi.

Referenced by jacobian().

 {
   for (const auto qp : make_range(qrule->n_points()))
   {
     for (const auto i : make_range(p_n_dofs))
     {
       for (const auto j : make_range(scalar_n_dofs))
       {
         {
           const Gradient phi((*scalar_phi)[j][qp], Number(0));
           Jpu(i, j) -= (*JxW)[qp] * ((*grad_scalar_phi)[i][qp] * phi);
         }
         {
           const Gradient phi(Number(0), (*scalar_phi)[j][qp]);
           Jpv(i, j) -= (*JxW)[qp] * ((*grad_scalar_phi)[i][qp] * phi);
         }
       }
       if (cavity)
         Jpglm(i, 0) -= (*JxW)[qp] * (*scalar_phi)[i][qp];
     }
 
     if (cavity)
     {
       libmesh_assert(scalar_n_dofs == p_n_dofs);
       for (const auto j : make_range(p_n_dofs))
         Jglmp(0, j) -= (*JxW)[qp] * (*scalar_phi)[j][qp];
     }
   }
 }

◆ pressure_volume_residual()

void libMesh::HDGProblem::pressure_volume_residual	(	DenseVector< Number > &	Rp,
		DenseVector< Number > &	Rglm
	)

private

Definition at line 279 of file hdg_problem.C.

References cavity, libMesh::PSoln::forcing(), global_lm_dof_value, libMesh::make_range(), mms, p_n_dofs, p_sol, p_true_soln, q_point, qrule, libMesh::Real, u_sol, and v_sol.

Referenced by residual().

 {
   for (const auto qp : make_range(qrule->n_points()))
   {
     // Prepare forcing function
     Real f = 0;
     if (mms)
       f = p_true_soln.forcing((*q_point)[qp]);
 
     const Gradient vel(u_sol[qp], v_sol[qp]);
     for (const auto i : make_range(p_n_dofs))
     {
       Rp(i) -= (*JxW)[qp] * ((*grad_scalar_phi)[i][qp] * vel);
 
       if (mms)
         // Pressure equation RHS
         Rp(i) -= (*JxW)[qp] * (*scalar_phi)[i][qp] * f;
 
       if (cavity)
         Rp(i) -= (*JxW)[qp] * (*scalar_phi)[i][qp] * global_lm_dof_value;
     }
 
     if (cavity)
       Rglm(0) -= (*JxW)[qp] * p_sol[qp];
   }
 }

◆ residual() [1/2]

void libMesh::HDGProblem::residual	(	const NumericVector< Number > &	X,
		NumericVector< Number > &	R,
		NonlinearImplicitSystem &	S
	)

overridevirtual

Definition at line 712 of file hdg_problem.C.

References libMesh::NumericVector< T >::add_vector(), cavity, libMesh::compute_qp_soln(), create_identity_residual(), current_bnd, dof_indices, libMesh::DofMap::dof_indices(), dof_map, libMesh::NumericVector< T >::get(), libMesh::MeshBase::get_boundary_info(), global_lm_dof_value, libMesh::invalid_uint, JxW_face, libMesh::libmesh_assert(), lm_face_residual(), lm_fe_face, lm_n_dofs, lm_phi_face, lm_u_dof_values, lm_u_sol, lm_v_dof_values, lm_v_sol, mesh, neigh, libMesh::Elem::neighbor_ptr(), p_dof_values, p_n_dofs, p_sol, pressure_dirichlet_residual(), pressure_face_residual(), pressure_volume_residual(), qface, qrule, qu_dof_values, qu_sol, qv_dof_values, qv_sol, libMesh::DenseVector< T >::resize(), right_bnd, scalar_dirichlet_residual(), scalar_face_residual(), scalar_fe, scalar_fe_face, scalar_n_dofs, scalar_phi, scalar_phi_face, scalar_volume_residual(), sigma_u, sigma_v, u_dof_values, u_sol, v_dof_values, v_sol, libMesh::System::variable_number(), vector_dirichlet_residual(), vector_face_residual(), vector_fe, vector_fe_face, vector_n_dofs, vector_phi, vector_phi_face, vector_volume_residual(), and libMesh::NumericVector< T >::zero().

 {
   R.zero();
 
   const auto u_num = S.variable_number("vel_x");
   const auto v_num = S.variable_number("vel_y");
   const auto qu_num = S.variable_number("qu");
   const auto qv_num = S.variable_number("qv");
   const auto lm_u_num = S.variable_number("lm_u");
   const auto lm_v_num = S.variable_number("lm_v");
   const auto p_num = S.variable_number("pressure");
   const auto global_lm_num = cavity ? S.variable_number("global_lm") : invalid_uint;
 
   auto & qu_dof_indices = dof_indices[qu_num];
   auto & u_dof_indices = dof_indices[u_num];
   auto & lm_u_dof_indices = dof_indices[lm_u_num];
   auto & qv_dof_indices = dof_indices[qv_num];
   auto & v_dof_indices = dof_indices[v_num];
   auto & lm_v_dof_indices = dof_indices[lm_v_num];
   auto & p_dof_indices = dof_indices[p_num];
   static std::vector<dof_id_type> dummy_indices;
   auto & global_lm_dof_indices = cavity ? dof_indices[global_lm_num] : dummy_indices;
 
   std::vector<boundary_id_type> boundary_ids;
   const auto & boundary_info = mesh->get_boundary_info();
   DenseVector<Number> Rqu, Rqv, Ru, Rv, Rlm_u, Rlm_v, Rp, Rglm;
 
   for (const auto & elem : mesh->active_local_element_ptr_range())
   {
     // Retrive our dof indices for all fields
     dof_map->dof_indices(elem, qu_dof_indices, qu_num);
     dof_map->dof_indices(elem, u_dof_indices, u_num);
     dof_map->dof_indices(elem, lm_u_dof_indices, lm_u_num);
     dof_map->dof_indices(elem, qv_dof_indices, qv_num);
     dof_map->dof_indices(elem, v_dof_indices, v_num);
     dof_map->dof_indices(elem, lm_v_dof_indices, lm_v_num);
     dof_map->dof_indices(elem, p_dof_indices, p_num);
     if (cavity)
     {
       dof_map->dof_indices(elem, global_lm_dof_indices, global_lm_num);
       libmesh_assert(global_lm_dof_indices.size() == 1);
     }
 
     vector_n_dofs = qu_dof_indices.size();
     scalar_n_dofs = u_dof_indices.size();
     lm_n_dofs = lm_u_dof_indices.size();
     p_n_dofs = p_dof_indices.size();
     libmesh_assert(p_n_dofs == scalar_n_dofs);
     Rqu.resize(vector_n_dofs);
     Rqv.resize(vector_n_dofs);
     Ru.resize(scalar_n_dofs);
     Rv.resize(scalar_n_dofs);
     Rlm_u.resize(lm_n_dofs);
     Rlm_v.resize(lm_n_dofs);
     Rp.resize(p_n_dofs);
     Rglm.resize(global_lm_dof_indices.size());
 
     // Reinit our volume FE objects
     vector_fe->reinit(elem);
     scalar_fe->reinit(elem);
 
     libmesh_assert_equal_to(vector_n_dofs, vector_phi->size());
     libmesh_assert_equal_to(scalar_n_dofs, scalar_phi->size());
 
     // Get our local element dof values
     X.get(qu_dof_indices, qu_dof_values);
     X.get(u_dof_indices, u_dof_values);
     X.get(lm_u_dof_indices, lm_u_dof_values);
     X.get(qv_dof_indices, qv_dof_values);
     X.get(v_dof_indices, v_dof_values);
     X.get(lm_v_dof_indices, lm_v_dof_values);
     X.get(p_dof_indices, p_dof_values);
     if (cavity)
       global_lm_dof_value = X(global_lm_dof_indices[0]);
 
     // Compute volumetric local qp solutions
     compute_qp_soln(qu_sol, qrule->n_points(), *vector_phi, qu_dof_values);
     compute_qp_soln(u_sol, qrule->n_points(), *scalar_phi, u_dof_values);
     compute_qp_soln(qv_sol, qrule->n_points(), *vector_phi, qv_dof_values);
     compute_qp_soln(v_sol, qrule->n_points(), *scalar_phi, v_dof_values);
     compute_qp_soln(p_sol, qrule->n_points(), *scalar_phi, p_dof_values);
 
     //
     // compute volumetric residuals and Jacobians
     //
 
     // qu and u
     vector_volume_residual(qu_sol, u_sol, Rqu);
     scalar_volume_residual(qu_sol, 0, sigma_u, Ru);
 
     // qv and v
     vector_volume_residual(qv_sol, v_sol, Rqv);
     scalar_volume_residual(qv_sol, 1, sigma_v, Rv);
 
     // p
     pressure_volume_residual(Rp, Rglm);
 
     for (auto side : elem->side_index_range())
     {
       neigh = elem->neighbor_ptr(side);
 
       // Reinit our face FE objects
       vector_fe_face->reinit(elem, side);
       scalar_fe_face->reinit(elem, side);
       lm_fe_face->reinit(elem, side);
 
       // Compute face local qp solutions
       compute_qp_soln(qu_sol, qface->n_points(), *vector_phi_face, qu_dof_values);
       compute_qp_soln(u_sol, qface->n_points(), *scalar_phi_face, u_dof_values);
       compute_qp_soln(lm_u_sol, qface->n_points(), *lm_phi_face, lm_u_dof_values);
       compute_qp_soln(qv_sol, qface->n_points(), *vector_phi_face, qv_dof_values);
       compute_qp_soln(v_sol, qface->n_points(), *scalar_phi_face, v_dof_values);
       compute_qp_soln(lm_v_sol, qface->n_points(), *lm_phi_face, lm_v_dof_values);
       compute_qp_soln(p_sol, qface->n_points(), *scalar_phi_face, p_dof_values);
 
       if (neigh == nullptr)
       {
         boundary_info.boundary_ids(elem, side, boundary_ids);
         libmesh_assert(boundary_ids.size() == 1);
         current_bnd = boundary_ids[0];
         if (cavity || (current_bnd != right_bnd))
         {
           // qu, u
           vector_dirichlet_residual(0, Rqu);
           scalar_dirichlet_residual(qu_sol, u_sol, 0, Ru);
 
           // qv, v
           vector_dirichlet_residual(1, Rqv);
           scalar_dirichlet_residual(qv_sol, v_sol, 1, Rv);
 
           // p
           pressure_dirichlet_residual(Rp);
 
           // Set the LMs on these Dirichlet boundary faces to 0
           create_identity_residual(*qface, *JxW_face, *lm_phi_face, lm_u_sol, lm_n_dofs, Rlm_u);
           create_identity_residual(*qface, *JxW_face, *lm_phi_face, lm_v_sol, lm_n_dofs, Rlm_v);
 
           continue;
         }
       }
 
       //
       // if we got here, then we are on an internal face or an outlet face
       //
 
       // qu, u, lm_u
       vector_face_residual(lm_u_sol, Rqu);
       scalar_face_residual(qu_sol, u_sol, lm_u_sol, 0, Ru);
       lm_face_residual(qu_sol, u_sol, lm_u_sol, 0, Rlm_u);
 
       // qv, v, lm_v
       vector_face_residual(lm_v_sol, Rqv);
       scalar_face_residual(qv_sol, v_sol, lm_v_sol, 1, Rv);
       lm_face_residual(qv_sol, v_sol, lm_v_sol, 1, Rlm_v);
 
       // p
       pressure_face_residual(Rp);
     }
 
     R.add_vector(Rqu, qu_dof_indices);
     R.add_vector(Rqv, qv_dof_indices);
     R.add_vector(Ru, u_dof_indices);
     R.add_vector(Rv, v_dof_indices);
     R.add_vector(Rlm_u, lm_u_dof_indices);
     R.add_vector(Rlm_v, lm_v_dof_indices);
     R.add_vector(Rp, p_dof_indices);
     if (cavity)
       R.add_vector(Rglm, global_lm_dof_indices);
   }
 }

◆ residual() [2/2]

virtual void libMesh::NonlinearImplicitSystem::ComputeResidual::residual	(	const NumericVector< Number > &	X,
		NumericVector< Number > &	R,
		sys_type &	S
	)

pure virtualinherited

Residual function.

This function will be called to compute the residual and must be implemented by the user in a derived class.

Referenced by libMesh::Problem_Interface::computeF(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_mffd_residual(), and libMesh::libmesh_petsc_snes_residual().

◆ scalar_dirichlet_jacobian()

void libMesh::HDGProblem::scalar_dirichlet_jacobian	(	const unsigned int	vel_component,
		DenseMatrix< Number > &	Jsq,
		DenseMatrix< Number > &	Jsp,
		DenseMatrix< Number > &	Jss
	)

private

Definition at line 479 of file hdg_problem.C.

References libMesh::make_range(), nu, p_n_dofs, qface, scalar_n_dofs, tau, and vector_n_dofs.

Referenced by jacobian().

 {
   for (const auto qp : make_range(qface->n_points()))
     for (const auto i : make_range(scalar_n_dofs))
     {
       for (const auto j : make_range(vector_n_dofs))
         Jsq(i, j) -= (*JxW_face)[qp] * nu * (*scalar_phi_face)[i][qp] *
                      ((*vector_phi_face)[j][qp] * (*normals)[qp]);
 
       for (const auto j : make_range(p_n_dofs))
       {
         Gradient p_phi;
         p_phi(vel_component) = (*scalar_phi_face)[j][qp];
         // pressure
         Jsp(i, j) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * (p_phi * (*normals)[qp]);
       }
 
       for (const auto j : make_range(scalar_n_dofs))
         Jss(i, j) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * tau * (*scalar_phi_face)[j][qp] *
                      (*normals)[qp] * (*normals)[qp];
     }
 }

◆ scalar_dirichlet_residual()

void libMesh::HDGProblem::scalar_dirichlet_residual	(	const std::vector< Gradient > &	vector_sol,
		const std::vector< Number > &	scalar_sol,
		const unsigned int	vel_component,
		DenseVector< Number > &	R
	)

private

Definition at line 441 of file hdg_problem.C.

References get_dirichlet_velocity(), libMesh::make_range(), nu, p_sol, qface, scalar_n_dofs, and tau.

Referenced by residual().

 {
   for (const auto qp : make_range(qface->n_points()))
   {
     Gradient qp_p;
     qp_p(vel_component) = p_sol[qp];
 
     const auto dirichlet_velocity = get_dirichlet_velocity(qp);
     const auto scalar_value = dirichlet_velocity(vel_component);
     ;
 
     for (const auto i : make_range(scalar_n_dofs))
     {
       // vector
       R(i) -= (*JxW_face)[qp] * nu * (*scalar_phi_face)[i][qp] * (vector_sol[qp] * (*normals)[qp]);
 
       // pressure
       R(i) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * (qp_p * (*normals)[qp]);
 
       // scalar from stabilization term
       R(i) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * tau * scalar_sol[qp] * (*normals)[qp] *
               (*normals)[qp];
 
       // dirichlet lm from stabilization term
       R(i) -= (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * tau * scalar_value * (*normals)[qp] *
               (*normals)[qp];
 
       // dirichlet lm from advection term
       R(i) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * (dirichlet_velocity * (*normals)[qp]) *
               scalar_value;
     }
   }
 }

◆ scalar_face_jacobian()

void libMesh::HDGProblem::scalar_face_jacobian	(	const unsigned int	vel_component,
		DenseMatrix< Number > &	Jsq,
		DenseMatrix< Number > &	Jsp,
		DenseMatrix< Number > &	Jss,
		DenseMatrix< Number > &	Jslm,
		DenseMatrix< Number > &	Js_lmu,
		DenseMatrix< Number > &	Js_lmv
	)

private

Definition at line 549 of file hdg_problem.C.

References current_bnd, lm_n_dofs, lm_phi_face, lm_u_sol, lm_v_sol, libMesh::make_range(), neigh, nu, p_n_dofs, qface, right_bnd, scalar_n_dofs, tau, vector_n_dofs, and vel_cross_vel_jacobian().

Referenced by jacobian().

 {
   for (const auto qp : make_range(qface->n_points()))
     for (const auto i : make_range(scalar_n_dofs))
     {
       if (neigh)
       {
         for (const auto j : make_range(vector_n_dofs))
           Jsq(i, j) -= (*JxW_face)[qp] * nu * (*scalar_phi_face)[i][qp] *
                        ((*vector_phi_face)[j][qp] * (*normals)[qp]);
 
         for (const auto j : make_range(p_n_dofs))
         {
           Gradient p_phi;
           p_phi(vel_component) = (*scalar_phi_face)[j][qp];
           // pressure
           Jsp(i, j) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * (p_phi * (*normals)[qp]);
         }
 
         for (const auto j : make_range(scalar_n_dofs))
           Jss(i, j) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * tau *
                        (*scalar_phi_face)[j][qp] * (*normals)[qp] * (*normals)[qp];
       }
       else
         libmesh_assert_msg(current_bnd == right_bnd,
                            "This method should only be called with an outflow boundary. "
                            "Dirichlet boundaries should call a different routine");
 
       for (const auto j : make_range(lm_n_dofs))
       {
         if (neigh)
           // from stabilization term
           Jslm(i, j) -= (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * tau * (*lm_phi_face)[j][qp] *
                         (*normals)[qp] * (*normals)[qp];
 
         //
         // from convection term
         //
 
         // derivatives wrt 0th component
         {
           const auto vel_cross_vel =
               vel_cross_vel_jacobian(lm_u_sol, lm_v_sol, qp, vel_component, 0, (*lm_phi_face), j);
           Js_lmu(i, j) +=
               (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * vel_cross_vel * (*normals)[qp];
         }
         // derivatives wrt 1th component
         {
           const auto vel_cross_vel =
               vel_cross_vel_jacobian(lm_u_sol, lm_v_sol, qp, vel_component, 1, (*lm_phi_face), j);
           Js_lmv(i, j) +=
               (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * vel_cross_vel * (*normals)[qp];
         }
       }
     }
 }

◆ scalar_face_residual()

void libMesh::HDGProblem::scalar_face_residual	(	const std::vector< Gradient > &	vector_sol,
		const std::vector< Number > &	scalar_sol,
		const std::vector< Number > &	lm_sol,
		const unsigned int	vel_component,
		DenseVector< Number > &	R
	)

private

Definition at line 506 of file hdg_problem.C.

References current_bnd, lm_u_sol, lm_v_sol, libMesh::make_range(), neigh, nu, p_sol, qface, right_bnd, scalar_n_dofs, tau, and vel_cross_vel_residual().

Referenced by residual().

 {
   for (const auto qp : make_range(qface->n_points()))
   {
     Gradient qp_p;
     qp_p(vel_component) = p_sol[qp];
     const auto vel_cross_vel = vel_cross_vel_residual(lm_u_sol, lm_v_sol, qp, vel_component);
 
     for (const auto i : make_range(scalar_n_dofs))
     {
       if (neigh)
       {
         // vector
         R(i) -=
             (*JxW_face)[qp] * nu * (*scalar_phi_face)[i][qp] * (vector_sol[qp] * (*normals)[qp]);
 
         // pressure
         R(i) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * (qp_p * (*normals)[qp]);
 
         // scalar from stabilization term
         R(i) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * tau * scalar_sol[qp] *
                 (*normals)[qp] * (*normals)[qp];
 
         // lm from stabilization term
         R(i) -= (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * tau * lm_sol[qp] * (*normals)[qp] *
                 (*normals)[qp];
       }
       else
         libmesh_assert_msg(current_bnd == right_bnd,
                            "This method should only be called with an outflow boundary. "
                            "Dirichlet boundaries should call a different routine");
 
       // lm from convection term
       R(i) += (*JxW_face)[qp] * (*scalar_phi_face)[i][qp] * vel_cross_vel * (*normals)[qp];
     }
   }
 }

◆ scalar_volume_jacobian()

void libMesh::HDGProblem::scalar_volume_jacobian	(	const unsigned int	vel_component,
		DenseMatrix< Number > &	Jsq,
		DenseMatrix< Number > &	Jsp,
		DenseMatrix< Number > &	Jsu,
		DenseMatrix< Number > &	Jsv
	)

private

Definition at line 238 of file hdg_problem.C.

References libMesh::make_range(), nu, p_n_dofs, qrule, scalar_n_dofs, scalar_phi, u_sol, v_sol, vector_n_dofs, and vel_cross_vel_jacobian().

Referenced by jacobian().

 {
   for (const auto qp : make_range(qrule->n_points()))
     for (const auto i : make_range(scalar_n_dofs))
     {
       // Scalar equation dependence on vector dofs
       for (const auto j : make_range(vector_n_dofs))
         Jsq(i, j) += (*JxW)[qp] * nu * ((*grad_scalar_phi)[i][qp] * (*vector_phi)[j][qp]);
 
       // Scalar equation dependence on pressure dofs
       for (const auto j : make_range(p_n_dofs))
       {
         Gradient p_phi;
         p_phi(vel_component) = (*scalar_phi)[j][qp];
         Jsp(i, j) -= (*JxW)[qp] * ((*grad_scalar_phi)[i][qp] * p_phi);
       }
 
       // Scalar equation dependence on scalar dofs
       for (const auto j : make_range(scalar_n_dofs))
       {
         // derivatives wrt 0th component
         {
           const auto vel_cross_vel =
               vel_cross_vel_jacobian(u_sol, v_sol, qp, vel_component, 0, (*scalar_phi), j);
           Jsu(i, j) -= (*JxW)[qp] * ((*grad_scalar_phi)[i][qp] * vel_cross_vel);
         }
         // derivatives wrt 1th component
         {
           const auto vel_cross_vel =
               vel_cross_vel_jacobian(u_sol, v_sol, qp, vel_component, 1, (*scalar_phi), j);
           Jsv(i, j) -= (*JxW)[qp] * ((*grad_scalar_phi)[i][qp] * vel_cross_vel);
         }
       }
     }
 }

◆ scalar_volume_residual()

void libMesh::HDGProblem::scalar_volume_residual	(	const std::vector< Gradient > &	vel_gradient,
		const unsigned int	vel_component,
		std::vector< Gradient > &	sigma,
		DenseVector< Number > &	R
	)

private

Definition at line 205 of file hdg_problem.C.

References compute_stress(), libMesh::make_range(), mms, q_point, qrule, libMesh::Real, scalar_n_dofs, u_sol, u_true_soln, v_sol, v_true_soln, and vel_cross_vel_residual().

Referenced by residual().

 {
   compute_stress(vel_gradient, vel_component, sigma);
   const auto & mms_info = vel_component == 0 ? static_cast<const ExactSoln &>(u_true_soln)
                                              : static_cast<const ExactSoln &>(v_true_soln);
   for (const auto qp : make_range(qrule->n_points()))
   {
     const auto vel_cross_vel = vel_cross_vel_residual(u_sol, v_sol, qp, vel_component);
 
     // Prepare forcing function
     Real f = 0;
     if (mms)
       f = mms_info.forcing((*q_point)[qp]);
 
     for (const auto i : make_range(scalar_n_dofs))
     {
       // Scalar equation dependence on vector and pressure dofs
       R(i) += (*JxW)[qp] * ((*grad_scalar_phi)[i][qp] * sigma[qp]);
 
       // Scalar equation dependence on scalar dofs
       R(i) -= (*JxW)[qp] * ((*grad_scalar_phi)[i][qp] * vel_cross_vel);
 
       if (mms)
         // Scalar equation RHS
         R(i) -= (*JxW)[qp] * (*scalar_phi)[i][qp] * f;
     }
   }
 }

◆ vector_dirichlet_residual()

void libMesh::HDGProblem::vector_dirichlet_residual	(	const unsigned int	vel_component,
		DenseVector< Number > &	R
	)

private

Definition at line 408 of file hdg_problem.C.

References get_dirichlet_velocity(), libMesh::make_range(), qface, and vector_n_dofs.

Referenced by residual().

 {
   for (const auto qp : make_range(qface->n_points()))
   {
     const auto scalar_value = get_dirichlet_velocity(qp)(vel_component);
 
     // External boundary -> Dirichlet faces -> Vector equation RHS
     for (const auto i : make_range(vector_n_dofs))
       R(i) -= (*JxW_face)[qp] * ((*vector_phi_face)[i][qp] * (*normals)[qp]) * scalar_value;
   }
 }

◆ vector_face_jacobian()

void libMesh::HDGProblem::vector_face_jacobian ( DenseMatrix< Number > & Jqlm )

private

Definition at line 430 of file hdg_problem.C.

References lm_n_dofs, lm_phi_face, libMesh::make_range(), qface, and vector_n_dofs.

Referenced by jacobian().

 {
   for (const auto qp : make_range(qface->n_points()))
     // Vector equation dependence on LM dofs
     for (const auto i : make_range(vector_n_dofs))
       for (const auto j : make_range(lm_n_dofs))
         Jqlm(i, j) -=
             (*JxW_face)[qp] * ((*vector_phi_face)[i][qp] * (*normals)[qp]) * (*lm_phi_face)[j][qp];
 }

◆ vector_face_residual()

void libMesh::HDGProblem::vector_face_residual	(	const std::vector< Number > &	lm_sol,
		DenseVector< Number > &	R
	)

private

Definition at line 421 of file hdg_problem.C.

References libMesh::make_range(), qface, and vector_n_dofs.

Referenced by residual().

 {
   for (const auto qp : make_range(qface->n_points()))
     // Vector equation dependence on LM dofs
     for (const auto i : make_range(vector_n_dofs))
       R(i) -= (*JxW_face)[qp] * ((*vector_phi_face)[i][qp] * (*normals)[qp]) * lm_sol[qp];
 }

◆ vector_volume_jacobian()

void libMesh::HDGProblem::vector_volume_jacobian	(	DenseMatrix< Number > &	Jqq,
		DenseMatrix< Number > &	Jqs
	)

private

Definition at line 161 of file hdg_problem.C.

References libMesh::make_range(), qrule, scalar_n_dofs, and vector_n_dofs.

Referenced by jacobian().

 {
   for (const auto qp : make_range(qrule->n_points()))
     for (const auto i : make_range(vector_n_dofs))
     {
       // Vector equation dependence on vector dofs
       for (const auto j : make_range(vector_n_dofs))
         Jqq(i, j) += (*JxW)[qp] * ((*vector_phi)[i][qp] * (*vector_phi)[j][qp]);
 
       // Vector equation dependence on scalar dofs
       for (const auto j : make_range(scalar_n_dofs))
         Jqs(i, j) += (*JxW)[qp] * ((*div_vector_phi)[i][qp] * (*scalar_phi)[j][qp]);
     }
 }

◆ vector_volume_residual()

void libMesh::HDGProblem::vector_volume_residual	(	const std::vector< Gradient > &	vector_sol,
		const std::vector< Number > &	scalar_sol,
		DenseVector< Number > &	R
	)

private

Definition at line 145 of file hdg_problem.C.

References libMesh::make_range(), qrule, and vector_n_dofs.

Referenced by residual().

 {
   for (const auto qp : make_range(qrule->n_points()))
     for (const auto i : make_range(vector_n_dofs))
     {
       // Vector equation dependence on vector dofs
       R(i) += (*JxW)[qp] * ((*vector_phi)[i][qp] * vector_sol[qp]);
 
       // Vector equation dependence on scalar dofs
       R(i) += (*JxW)[qp] * ((*div_vector_phi)[i][qp] * scalar_sol[qp]);
     }
 }

◆ vel_cross_vel_jacobian()

NumberVectorValue libMesh::HDGProblem::vel_cross_vel_jacobian	(	const std::vector< Number > &	u_sol_local,
		const std::vector< Number > &	v_sol_local,
		const unsigned int	qp,
		const unsigned int	vel_component,
		const unsigned int	vel_j_component,
		const std::vector< std::vector< Real >> &	phi,
		const unsigned int	j
	)		const

private

Definition at line 187 of file hdg_problem.C.

Referenced by lm_face_jacobian(), scalar_face_jacobian(), and scalar_volume_jacobian().

 {
   const NumberVectorValue U(u_sol_local[qp], v_sol_local[qp]);
   NumberVectorValue vector_phi_local;
   vector_phi_local(vel_j_component) = phi[j][qp];
   auto ret = vector_phi_local * U(vel_component);
   if (vel_component == vel_j_component)
     ret += U * phi[j][qp];
   return ret;
 }

◆ vel_cross_vel_residual()

NumberVectorValue libMesh::HDGProblem::vel_cross_vel_residual	(	const std::vector< Number > &	u_sol_local,
		const std::vector< Number > &	v_sol_local,
		const unsigned int	qp,
		const unsigned int	vel_component
	)		const

private

Definition at line 177 of file hdg_problem.C.

Referenced by lm_face_residual(), scalar_face_residual(), and scalar_volume_residual().

 {
   const NumberVectorValue U(u_sol_local[qp], v_sol_local[qp]);
   return U * U(vel_component);
 }

Member Data Documentation

◆ bottom_bnd

boundary_id_type libMesh::HDGProblem::bottom_bnd

Definition at line 60 of file hdg_problem.h.

Referenced by init().

◆ cavity

bool libMesh::HDGProblem::cavity

Definition at line 66 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), init(), jacobian(), pressure_volume_jacobian(), pressure_volume_residual(), and residual().

◆ current_bnd

boundary_id_type libMesh::HDGProblem::current_bnd

private

Definition at line 251 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), jacobian(), lm_face_jacobian(), lm_face_residual(), residual(), scalar_face_jacobian(), and scalar_face_residual().

◆ div_vector_phi

const std::vector<std::vector<Real> >* libMesh::HDGProblem::div_vector_phi

private

Definition at line 204 of file hdg_problem.h.

Referenced by init().

◆ dof_indices

std::unordered_map<unsigned int, std::vector<dof_id_type> > libMesh::HDGProblem::dof_indices

private

Definition at line 215 of file hdg_problem.h.

Referenced by add_matrix(), jacobian(), and residual().

◆ dof_map

const DofMap* libMesh::HDGProblem::dof_map

Definition at line 44 of file hdg_problem.h.

Referenced by jacobian(), main(), and residual().

◆ global_lm_dof_value

Number libMesh::HDGProblem::global_lm_dof_value

private

Definition at line 238 of file hdg_problem.h.

Referenced by jacobian(), pressure_volume_residual(), and residual().

◆ global_lm_n_dofs

std::size_t libMesh::HDGProblem::global_lm_n_dofs

private

Definition at line 245 of file hdg_problem.h.

Referenced by init().

◆ grad_scalar_phi

const std::vector<std::vector<RealVectorValue> >* libMesh::HDGProblem::grad_scalar_phi

private

Definition at line 203 of file hdg_problem.h.

Referenced by init().

◆ JxW

const std::vector<Real>* libMesh::HDGProblem::JxW

private

Definition at line 199 of file hdg_problem.h.

Referenced by init().

◆ JxW_face

const std::vector<Real>* libMesh::HDGProblem::JxW_face

private

Definition at line 207 of file hdg_problem.h.

Referenced by init(), jacobian(), and residual().

◆ left_bnd

boundary_id_type libMesh::HDGProblem::left_bnd

Definition at line 57 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), and init().

◆ lm_fe_face

std::unique_ptr<FEBase> libMesh::HDGProblem::lm_fe_face

Definition at line 53 of file hdg_problem.h.

Referenced by init(), jacobian(), main(), and residual().

◆ lm_n_dofs

std::size_t libMesh::HDGProblem::lm_n_dofs

private

Definition at line 243 of file hdg_problem.h.

Referenced by jacobian(), lm_face_jacobian(), lm_face_residual(), pressure_face_jacobian(), residual(), scalar_face_jacobian(), and vector_face_jacobian().

◆ lm_phi_face

const std::vector<std::vector<Real> >* libMesh::HDGProblem::lm_phi_face

private

Definition at line 211 of file hdg_problem.h.

Referenced by init(), jacobian(), lm_face_jacobian(), pressure_face_jacobian(), residual(), scalar_face_jacobian(), and vector_face_jacobian().

◆ lm_u_dof_values

std::vector<Number> libMesh::HDGProblem::lm_u_dof_values

private

Definition at line 233 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ lm_u_sol

std::vector<Number> libMesh::HDGProblem::lm_u_sol

private

Definition at line 220 of file hdg_problem.h.

Referenced by jacobian(), lm_face_jacobian(), lm_face_residual(), pressure_face_residual(), residual(), scalar_face_jacobian(), and scalar_face_residual().

◆ lm_v_dof_values

std::vector<Number> libMesh::HDGProblem::lm_v_dof_values

private

Definition at line 236 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ lm_v_sol

std::vector<Number> libMesh::HDGProblem::lm_v_sol

private

Definition at line 223 of file hdg_problem.h.

Referenced by jacobian(), lm_face_jacobian(), lm_face_residual(), pressure_face_residual(), residual(), scalar_face_jacobian(), and scalar_face_residual().

◆ mesh

const MeshBase* libMesh::HDGProblem::mesh

Definition at line 43 of file hdg_problem.h.

Referenced by init(), jacobian(), main(), and residual().

◆ mms

bool libMesh::HDGProblem::mms

Definition at line 74 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), main(), pressure_volume_residual(), and scalar_volume_residual().

◆ neigh

const Elem* libMesh::HDGProblem::neigh

private

Definition at line 254 of file hdg_problem.h.

Referenced by jacobian(), lm_face_jacobian(), lm_face_residual(), residual(), scalar_face_jacobian(), and scalar_face_residual().

◆ normals

const std::vector<Point>* libMesh::HDGProblem::normals

private

Definition at line 212 of file hdg_problem.h.

Referenced by init().

◆ nu

Real libMesh::HDGProblem::nu

Definition at line 63 of file hdg_problem.h.

Referenced by compute_stress(), lm_face_jacobian(), lm_face_residual(), scalar_dirichlet_jacobian(), scalar_dirichlet_residual(), scalar_face_jacobian(), scalar_face_residual(), and scalar_volume_jacobian().

◆ p_dof_values

std::vector<Number> libMesh::HDGProblem::p_dof_values

private

Definition at line 237 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ p_n_dofs

std::size_t libMesh::HDGProblem::p_n_dofs

private

Definition at line 244 of file hdg_problem.h.

Referenced by jacobian(), lm_face_jacobian(), pressure_dirichlet_residual(), pressure_face_jacobian(), pressure_face_residual(), pressure_volume_jacobian(), pressure_volume_residual(), residual(), scalar_dirichlet_jacobian(), scalar_face_jacobian(), and scalar_volume_jacobian().

◆ p_sol

std::vector<Number> libMesh::HDGProblem::p_sol

private

Definition at line 224 of file hdg_problem.h.

Referenced by compute_stress(), jacobian(), lm_face_residual(), pressure_volume_residual(), residual(), scalar_dirichlet_residual(), and scalar_face_residual().

◆ p_true_soln

const PSoln libMesh::HDGProblem::p_true_soln

Definition at line 71 of file hdg_problem.h.

Referenced by main(), and pressure_volume_residual().

◆ q_point

const std::vector<Point>* libMesh::HDGProblem::q_point

private

Definition at line 200 of file hdg_problem.h.

Referenced by init(), pressure_volume_residual(), and scalar_volume_residual().

◆ qbar

std::vector<Number> libMesh::HDGProblem::qbar

private

Definition at line 257 of file hdg_problem.h.

◆ qface

std::unique_ptr<QBase> libMesh::HDGProblem::qface

Definition at line 54 of file hdg_problem.h.

Referenced by init(), jacobian(), lm_face_jacobian(), lm_face_residual(), main(), pressure_dirichlet_residual(), pressure_face_jacobian(), pressure_face_residual(), residual(), scalar_dirichlet_jacobian(), scalar_dirichlet_residual(), scalar_face_jacobian(), scalar_face_residual(), vector_dirichlet_residual(), vector_face_jacobian(), and vector_face_residual().

◆ qface_point

const std::vector<Point>* libMesh::HDGProblem::qface_point

private

Definition at line 208 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), and init().

◆ qrule

std::unique_ptr<QBase> libMesh::HDGProblem::qrule

Definition at line 50 of file hdg_problem.h.

Referenced by compute_stress(), init(), jacobian(), main(), pressure_volume_jacobian(), pressure_volume_residual(), residual(), scalar_volume_jacobian(), scalar_volume_residual(), vector_volume_jacobian(), and vector_volume_residual().

◆ qu_dof_values

std::vector<Number> libMesh::HDGProblem::qu_dof_values

private

Definition at line 231 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ qu_sol

std::vector<Gradient> libMesh::HDGProblem::qu_sol

private

Definition at line 218 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ qv_dof_values

std::vector<Number> libMesh::HDGProblem::qv_dof_values

private

Definition at line 234 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ qv_sol

std::vector<Gradient> libMesh::HDGProblem::qv_sol

private

Definition at line 221 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ right_bnd

boundary_id_type libMesh::HDGProblem::right_bnd

Definition at line 59 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), init(), jacobian(), lm_face_jacobian(), lm_face_residual(), residual(), scalar_face_jacobian(), and scalar_face_residual().

◆ sc

StaticCondensation* libMesh::HDGProblem::sc

Definition at line 45 of file hdg_problem.h.

Referenced by jacobian(), and main().

◆ scalar_fe

std::unique_ptr<FEBase> libMesh::HDGProblem::scalar_fe

Definition at line 49 of file hdg_problem.h.

Referenced by init(), jacobian(), main(), and residual().

◆ scalar_fe_face

std::unique_ptr<FEBase> libMesh::HDGProblem::scalar_fe_face

Definition at line 52 of file hdg_problem.h.

Referenced by init(), jacobian(), main(), and residual().

◆ scalar_n_dofs

std::size_t libMesh::HDGProblem::scalar_n_dofs

private

Definition at line 242 of file hdg_problem.h.

Referenced by jacobian(), lm_face_jacobian(), pressure_volume_jacobian(), residual(), scalar_dirichlet_jacobian(), scalar_dirichlet_residual(), scalar_face_jacobian(), scalar_face_residual(), scalar_volume_jacobian(), scalar_volume_residual(), and vector_volume_jacobian().

◆ scalar_phi

const std::vector<std::vector<Real> >* libMesh::HDGProblem::scalar_phi

private

Definition at line 202 of file hdg_problem.h.

Referenced by init(), jacobian(), pressure_volume_jacobian(), residual(), and scalar_volume_jacobian().

◆ scalar_phi_face

const std::vector<std::vector<Real> >* libMesh::HDGProblem::scalar_phi_face

private

Definition at line 210 of file hdg_problem.h.

Referenced by init(), jacobian(), and residual().

◆ sigma_u

std::vector<Gradient> libMesh::HDGProblem::sigma_u

private

Definition at line 227 of file hdg_problem.h.

Referenced by residual().

◆ sigma_v

std::vector<Gradient> libMesh::HDGProblem::sigma_v

private

Definition at line 228 of file hdg_problem.h.

Referenced by residual().

◆ system

System* libMesh::HDGProblem::system

Definition at line 42 of file hdg_problem.h.

Referenced by main().

◆ tau

constexpr Real libMesh::HDGProblem::tau = 1

staticprivate

Definition at line 248 of file hdg_problem.h.

Referenced by lm_face_jacobian(), lm_face_residual(), scalar_dirichlet_jacobian(), scalar_dirichlet_residual(), scalar_face_jacobian(), and scalar_face_residual().

◆ top_bnd

boundary_id_type libMesh::HDGProblem::top_bnd

Definition at line 58 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), and init().

◆ u_dof_values

std::vector<Number> libMesh::HDGProblem::u_dof_values

private

Definition at line 232 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ u_sol

std::vector<Number> libMesh::HDGProblem::u_sol

private

Definition at line 219 of file hdg_problem.h.

Referenced by jacobian(), pressure_volume_residual(), residual(), scalar_volume_jacobian(), and scalar_volume_residual().

◆ u_true_soln

const USoln libMesh::HDGProblem::u_true_soln

Definition at line 69 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), main(), and scalar_volume_residual().

◆ v_dof_values

std::vector<Number> libMesh::HDGProblem::v_dof_values

private

Definition at line 235 of file hdg_problem.h.

Referenced by jacobian(), and residual().

◆ v_sol

std::vector<Number> libMesh::HDGProblem::v_sol

private

Definition at line 222 of file hdg_problem.h.

Referenced by jacobian(), pressure_volume_residual(), residual(), scalar_volume_jacobian(), and scalar_volume_residual().

◆ v_true_soln

const VSoln libMesh::HDGProblem::v_true_soln

Definition at line 70 of file hdg_problem.h.

Referenced by get_dirichlet_velocity(), main(), and scalar_volume_residual().

◆ vector_fe

std::unique_ptr<FEVectorBase> libMesh::HDGProblem::vector_fe

Definition at line 48 of file hdg_problem.h.

Referenced by init(), jacobian(), main(), and residual().

◆ vector_fe_face

std::unique_ptr<FEVectorBase> libMesh::HDGProblem::vector_fe_face

Definition at line 51 of file hdg_problem.h.

Referenced by init(), jacobian(), main(), and residual().

◆ vector_n_dofs

std::size_t libMesh::HDGProblem::vector_n_dofs

private

Definition at line 241 of file hdg_problem.h.

Referenced by jacobian(), lm_face_jacobian(), residual(), scalar_dirichlet_jacobian(), scalar_face_jacobian(), scalar_volume_jacobian(), vector_dirichlet_residual(), vector_face_jacobian(), vector_face_residual(), vector_volume_jacobian(), and vector_volume_residual().

◆ vector_phi

const std::vector<std::vector<RealVectorValue> >* libMesh::HDGProblem::vector_phi

private

Definition at line 201 of file hdg_problem.h.

Referenced by init(), jacobian(), and residual().

◆ vector_phi_face

const std::vector<std::vector<RealVectorValue> >* libMesh::HDGProblem::vector_phi_face

private

Definition at line 209 of file hdg_problem.h.

Referenced by init(), jacobian(), and residual().

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

examples/vector_fe/vector_fe_ex9/hdg_problem.h
examples/vector_fe/vector_fe_ex9/hdg_problem.C

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ HDGProblem()

◆ ~HDGProblem()

Member Function Documentation

◆ add_matrix()

◆ compute_stress()

◆ create_identity_jacobian()

◆ create_identity_residual()

◆ get_dirichlet_velocity()

◆ init()

◆ jacobian() [1/2]

◆ jacobian() [2/2]

◆ lm_face_jacobian()

◆ lm_face_residual()

◆ pressure_dirichlet_residual()

◆ pressure_face_jacobian()

◆ pressure_face_residual()

◆ pressure_volume_jacobian()

◆ pressure_volume_residual()

◆ residual() [1/2]

◆ residual() [2/2]

◆ scalar_dirichlet_jacobian()

◆ scalar_dirichlet_residual()

◆ scalar_face_jacobian()

◆ scalar_face_residual()

◆ scalar_volume_jacobian()

◆ scalar_volume_residual()

◆ vector_dirichlet_residual()

◆ vector_face_jacobian()

◆ vector_face_residual()

◆ vector_volume_jacobian()

◆ vector_volume_residual()

◆ vel_cross_vel_jacobian()

◆ vel_cross_vel_residual()

Member Data Documentation

◆ bottom_bnd

◆ cavity

◆ current_bnd

◆ div_vector_phi

◆ dof_indices

◆ dof_map

◆ global_lm_dof_value

◆ global_lm_n_dofs

◆ grad_scalar_phi

◆ JxW

◆ JxW_face

◆ left_bnd

◆ lm_fe_face

◆ lm_n_dofs

◆ lm_phi_face

◆ lm_u_dof_values

◆ lm_u_sol

◆ lm_v_dof_values

◆ lm_v_sol

◆ mesh

◆ mms

◆ neigh

◆ normals

◆ nu

◆ p_dof_values

◆ p_n_dofs

◆ p_sol

◆ p_true_soln

◆ q_point

◆ qbar

◆ qface

◆ qface_point

◆ qrule

◆ qu_dof_values

◆ qu_sol

◆ qv_dof_values

◆ qv_sol

◆ right_bnd

◆ sc