#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
	Residual function.

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

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.

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

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

Referenced by jacobian().

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

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

References libMesh::make_range(), nu, p_sol, qrule, and libMesh::DenseMatrix< T >::resize().

Referenced by scalar_volume_residual().

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

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

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

Referenced by jacobian().

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

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

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

Referenced by residual().

◆ get_dirichlet_velocity()

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

private

Definition at line 371 of file hdg_problem.C.

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

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

◆ init()

void libMesh::HDGProblem::init ( )

Definition at line 65 of file hdg_problem.C.

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

References bottom_bnd, cavity, div_vector_phi, libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::get_id_by_name(), 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().

◆ jacobian()

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

overridevirtual

Jacobian function.

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

Implements libMesh::NonlinearImplicitSystem::ComputeJacobian.

Definition at line 896 of file hdg_problem.C.

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

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

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

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

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

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

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

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

◆ pressure_dirichlet_residual()

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

private

Definition at line 396 of file hdg_problem.C.

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

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

Referenced by residual().

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

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

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

Referenced by jacobian().

◆ pressure_face_residual()

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

private

Definition at line 341 of file hdg_problem.C.

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

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

Referenced by residual().

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

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

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

Referenced by jacobian().

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

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

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

◆ residual()

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

overridevirtual

Residual function.

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

Implements libMesh::NonlinearImplicitSystem::ComputeResidual.

Definition at line 712 of file hdg_problem.C.

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

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

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

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

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

Referenced by jacobian().

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

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

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

Referenced by residual().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Referenced by residual().

◆ vector_face_jacobian()

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

private

Definition at line 430 of file hdg_problem.C.

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

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

Referenced by jacobian().

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

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

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

Referenced by residual().

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

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

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

Referenced by jacobian().

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

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

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

Referenced by residual().

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

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

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

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

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

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

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

staticconstexprprivate

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

◆ lm_face_jacobian()

◆ lm_face_residual()

◆ pressure_dirichlet_residual()

◆ pressure_face_jacobian()

◆ pressure_face_residual()

◆ pressure_volume_jacobian()

◆ pressure_volume_residual()

◆ residual()

◆ 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

◆ scalar_fe

◆ scalar_fe_face