GRINS::IncompressibleNavierStokesStabilizationHelper Class Reference

#include <inc_navier_stokes_stab_helper.h>

Inheritance diagram for GRINS::IncompressibleNavierStokesStabilizationHelper:

Collaboration diagram for GRINS::IncompressibleNavierStokesStabilizationHelper:

Public Member Functions
	IncompressibleNavierStokesStabilizationHelper (const std::string &helper_name, const GetPot &input)
	~IncompressibleNavierStokesStabilizationHelper ()
libMesh::Real	compute_tau_continuity (libMesh::Real tau_C, libMesh::RealGradient &g) const
void	compute_tau_continuity_and_derivs (libMesh::Real tau_M, libMesh::Real d_tau_M_d_rho, libMesh::Gradient d_tau_M_d_U, libMesh::RealGradient &g, libMesh::Real &tau_C, libMesh::Real &d_tau_C_d_rho, libMesh::Gradient &d_tau_C_d_U) const
libMesh::Real	compute_tau_momentum (AssemblyContext &c, unsigned int qp, libMesh::RealGradient &g, libMesh::RealTensor &G, libMesh::Real rho, libMesh::Gradient U, libMesh::Real mu, bool is_steady) const
void	compute_tau_momentum_and_derivs (AssemblyContext &c, unsigned int qp, libMesh::RealGradient &g, libMesh::RealTensor &G, libMesh::Real rho, libMesh::Gradient U, libMesh::Real T, libMesh::Real &tau_M, libMesh::Real &d_tau_M_d_rho, libMesh::Gradient &d_tau_M_d_U, bool is_steady) const
libMesh::Real	compute_tau (AssemblyContext &c, unsigned int qp, libMesh::Real mat_prop_sq, libMesh::RealGradient &g, libMesh::RealTensor &G, libMesh::Real rho, libMesh::Gradient U, bool is_steady) const
void	compute_tau_and_derivs (AssemblyContext &c, unsigned int qp, libMesh::Real mat_prop_sq, libMesh::RealGradient &g, libMesh::RealTensor &G, libMesh::Real rho, libMesh::Gradient U, libMesh::Real &tau, libMesh::Real &d_tau_d_rho, libMesh::Gradient &d_tau_d_U, bool is_steady) const
libMesh::Real	compute_res_continuity (AssemblyContext &context, unsigned int qp) const
void	compute_res_continuity_and_derivs (AssemblyContext &context, unsigned int qp, libMesh::Real &res_C, libMesh::Tensor &d_res_C_dgradU) const
libMesh::RealGradient	compute_res_momentum_steady (AssemblyContext &context, unsigned int qp, const libMesh::Real rho, const libMesh::Real mu) const
void	compute_res_momentum_steady_and_derivs (AssemblyContext &context, unsigned int qp, const libMesh::Real rho, const libMesh::Real mu, libMesh::Gradient &res_M, libMesh::Tensor &d_res_M_dgradp, libMesh::Tensor &d_res_M_dU, libMesh::Gradient &d_res_Muvw_dgraduvw, libMesh::Tensor &d_res_Muvw_dhessuvw) const
libMesh::RealGradient	compute_res_momentum_transient (AssemblyContext &context, unsigned int qp, const libMesh::Real rho) const
void	compute_res_momentum_transient_and_derivs (AssemblyContext &context, unsigned int qp, const libMesh::Real rho, libMesh::RealGradient &res_M, libMesh::Real &d_res_Muvw_duvw) const
libMesh::RealGradient	UdotGradU (libMesh::Gradient &U, libMesh::Gradient &grad_u, libMesh::Gradient &grad_v) const
libMesh::RealGradient	UdotGradU (libMesh::Gradient &U, libMesh::Gradient &grad_u, libMesh::Gradient &grad_v, libMesh::Gradient &grad_w) const
libMesh::RealGradient	div_GradU (libMesh::RealTensor &hess_u, libMesh::RealTensor &hess_v) const
libMesh::RealGradient	div_GradU_axi (libMesh::Real r, const libMesh::Gradient &U, const libMesh::Gradient &grad_u, const libMesh::Gradient &grad_v, const libMesh::RealTensor &hess_u, const libMesh::RealTensor &hess_v) const
libMesh::RealGradient	div_GradU (libMesh::RealTensor &hess_u, libMesh::RealTensor &hess_v, libMesh::RealTensor &hess_w) const
libMesh::RealGradient	div_GradU_T (libMesh::RealTensor &hess_u, libMesh::RealTensor &hess_v) const
libMesh::RealGradient	div_GradU_T_axi (libMesh::Real r, const libMesh::Gradient &U, const libMesh::Gradient &grad_u, const libMesh::RealTensor &hess_u, const libMesh::RealTensor &hess_v) const
libMesh::RealGradient	div_GradU_T (libMesh::RealTensor &hess_u, libMesh::RealTensor &hess_v, libMesh::RealTensor &hess_w) const
libMesh::RealGradient	div_divU_I (libMesh::RealTensor &hess_u, libMesh::RealTensor &hess_v) const
libMesh::RealGradient	div_divU_I_axi (libMesh::Real r, const libMesh::Gradient &U, const libMesh::Gradient &grad_u, const libMesh::RealTensor &hess_u, const libMesh::RealTensor &hess_v) const
libMesh::RealGradient	div_divU_I (libMesh::RealTensor &hess_u, libMesh::RealTensor &hess_v, libMesh::RealTensor &hess_w) const
Public Member Functions inherited from GRINS::StabilizationHelper
	StabilizationHelper (const std::string &helper_name)
	~StabilizationHelper ()
libMesh::RealGradient	compute_g (libMesh::FEBase *fe, AssemblyContext &c, unsigned int qp) const
libMesh::RealTensor	compute_G (libMesh::FEBase *fe, AssemblyContext &c, unsigned int qp) const
Public Member Functions inherited from GRINS::ParameterUser
	ParameterUser (const std::string &user_name)
virtual	~ParameterUser ()
virtual void	set_parameter (libMesh::Number &param_variable, const GetPot &input, const std::string &param_name, libMesh::Number param_default)
	Each subclass can simultaneously read a parameter value from. More...
virtual void	set_parameter (libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &func, const GetPot &input, const std::string &func_param_name, const std::string &param_default)
	Each subclass can simultaneously read a parsed function from. More...
virtual void	set_parameter (libMesh::ParsedFEMFunction< libMesh::Number > &func, const GetPot &input, const std::string &func_param_name, const std::string &param_default)
	Each subclass can simultaneously read a parsed function from. More...
virtual void	move_parameter (const libMesh::Number &old_parameter, libMesh::Number &new_parameter)
	When cloning an object, we need to update parameter pointers. More...
virtual void	move_parameter (const libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &old_func, libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &new_func)
	When cloning an object, we need to update parameter pointers. More...
virtual void	move_parameter (const libMesh::ParsedFEMFunction< libMesh::Number > &old_func, libMesh::ParsedFEMFunction< libMesh::Number > &new_func)
	When cloning an object, we need to update parameter pointers. More...
virtual void	register_parameter (const std::string &param_name, libMesh::ParameterMultiAccessor< libMesh::Number > &param_pointer) const
	Each subclass will register its copy of an independent. More...

Protected Attributes
libMesh::Real	_C
libMesh::Real	_tau_factor
const VelocityFEVariables &	_flow_vars
const PressureFEVariable &	_press_var

Additional Inherited Members
Static Public Attributes inherited from GRINS::ParameterUser
static std::string	zero_vector_function = std::string("{0}")
	A parseable function string with LIBMESH_DIM components, all 0. More...

Detailed Description

Definition at line 41 of file inc_navier_stokes_stab_helper.h.

Constructor & Destructor Documentation

GRINS::IncompressibleNavierStokesStabilizationHelper::IncompressibleNavierStokesStabilizationHelper	(	const std::string &	helper_name,
		const GetPot &	input
	)

Definition at line 44 of file inc_navier_stokes_stab_helper.C.

    : StabilizationHelper(helper_name),
      _C(1),
      _tau_factor(0.5),
      _flow_vars(GRINSPrivate::VariableWarehouse::get_variable_subclass<VelocityFEVariables>(VariablesParsing::velocity_section())),
      _press_var(GRINSPrivate::VariableWarehouse::get_variable_subclass<PressureFEVariable>(VariablesParsing::pressure_section()))
  {
    if (input.have_variable("Stabilization/tau_constant_vel"))
      this->set_parameter
        (_C, input, "Stabilization/tau_constant_vel", _C );
    else
      this->set_parameter
        (_C, input, "Stabilization/tau_constant", _C );

    if (input.have_variable("Stabilization/tau_factor_vel"))
      this->set_parameter
        (_tau_factor, input, "Stabilization/tau_factor_vel", _tau_factor );
    else
      this->set_parameter
        (_tau_factor, input, "Stabilization/tau_factor", _tau_factor );

    return;
  }

GRINS::IncompressibleNavierStokesStabilizationHelper::~IncompressibleNavierStokesStabilizationHelper

(

)

Definition at line 69 of file inc_navier_stokes_stab_helper.C.

  {
    return;
  }

Member Function Documentation

libMesh::Real GRINS::IncompressibleNavierStokesStabilizationHelper::compute_res_continuity	(	AssemblyContext &	context,
		unsigned int	qp
	)		const

Definition at line 168 of file inc_navier_stokes_stab_helper.C.

References _flow_vars, GRINS::VelocityFEVariables::u(), GRINS::VelocityFEVariables::v(), and GRINS::VelocityFEVariables::w().

  {
    libMesh::RealGradient grad_u, grad_v;

    grad_u = context.fixed_interior_gradient(this->_flow_vars.u(), qp);
    grad_v = context.fixed_interior_gradient(this->_flow_vars.v(), qp);

    libMesh::Real divU = grad_u(0) + grad_v(1);

    if( context.get_system().get_mesh().mesh_dimension() == 3 )
      {
        divU += (context.fixed_interior_gradient(this->_flow_vars.w(), qp))(2);
      }

    return divU;
  }

void GRINS::IncompressibleNavierStokesStabilizationHelper::compute_res_continuity_and_derivs	(	AssemblyContext &	context,
		unsigned int	qp,
		libMesh::Real &	res_C,
		libMesh::Tensor &	d_res_C_dgradU
	)		const

Definition at line 187 of file inc_navier_stokes_stab_helper.C.

  {
    libMesh::RealGradient grad_u, grad_v;

    grad_u = context.fixed_interior_gradient(this->_flow_vars.u(), qp);
    grad_v = context.fixed_interior_gradient(this->_flow_vars.v(), qp);

    libMesh::Real divU = grad_u(0) + grad_v(1);
    d_res_C_dgradU = 0;
    d_res_C_dgradU(0,0) = 1;
    d_res_C_dgradU(1,1) = 1;

    if( context.get_system().get_mesh().mesh_dimension() == 3 )
      {
        divU += (context.fixed_interior_gradient(this->_flow_vars.w(), qp))(2);
        d_res_C_dgradU(2,2) = 1;
      }

    res_C = divU;
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::compute_res_momentum_steady	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho,
		const libMesh::Real	mu
	)		const

Definition at line 212 of file inc_navier_stokes_stab_helper.C.

References _flow_vars, _press_var, div_GradU(), GRINS::PressureFEVariable::p(), GRINS::VelocityFEVariables::u(), UdotGradU(), GRINS::VelocityFEVariables::v(), and GRINS::VelocityFEVariables::w().

  {
    libMesh::RealGradient U( context.fixed_interior_value(this->_flow_vars.u(), qp),
                             context.fixed_interior_value(this->_flow_vars.v(), qp) );
    if(context.get_system().get_mesh().mesh_dimension() == 3)
      U(2) = context.fixed_interior_value(this->_flow_vars.w(), qp);

    libMesh::RealGradient grad_p = context.fixed_interior_gradient(this->_press_var.p(), qp);

    libMesh::RealGradient grad_u = context.fixed_interior_gradient(this->_flow_vars.u(), qp);
    libMesh::RealGradient grad_v = context.fixed_interior_gradient(this->_flow_vars.v(), qp);

    libMesh::RealTensor hess_u = context.fixed_interior_hessian(this->_flow_vars.u(), qp);
    libMesh::RealTensor hess_v = context.fixed_interior_hessian(this->_flow_vars.v(), qp);

    libMesh::RealGradient rhoUdotGradU;
    libMesh::RealGradient divGradU;

    if( context.get_system().get_mesh().mesh_dimension() < 3 )
      {
        rhoUdotGradU = rho*this->UdotGradU( U, grad_u, grad_v );
        divGradU  = this->div_GradU( hess_u, hess_v );
      }
    else
      {
        libMesh::RealGradient grad_w = context.fixed_interior_gradient(this->_flow_vars.w(), qp);
        libMesh::RealTensor hess_w = context.fixed_interior_hessian(this->_flow_vars.w(), qp);

        rhoUdotGradU = rho*this->UdotGradU( U, grad_u, grad_v, grad_w );

        divGradU  = this->div_GradU( hess_u, hess_v, hess_w );
      }

    return rhoUdotGradU + grad_p - mu*divGradU;
  }

void GRINS::IncompressibleNavierStokesStabilizationHelper::compute_res_momentum_steady_and_derivs	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho,
		const libMesh::Real	mu,
		libMesh::Gradient &	res_M,
		libMesh::Tensor &	d_res_M_dgradp,
		libMesh::Tensor &	d_res_M_dU,
		libMesh::Gradient &	d_res_Muvw_dgraduvw,
		libMesh::Tensor &	d_res_Muvw_dhessuvw
	)		const

Definition at line 250 of file inc_navier_stokes_stab_helper.C.

  {
    libMesh::RealGradient U( context.fixed_interior_value(this->_flow_vars.u(), qp),
                             context.fixed_interior_value(this->_flow_vars.v(), qp) );
    if(context.get_system().get_mesh().mesh_dimension() == 3)
      U(2) = context.fixed_interior_value(this->_flow_vars.w(), qp);

    libMesh::RealGradient grad_p = context.fixed_interior_gradient(this->_press_var.p(), qp);

    libMesh::RealGradient grad_u = context.fixed_interior_gradient(this->_flow_vars.u(), qp);
    libMesh::RealGradient grad_v = context.fixed_interior_gradient(this->_flow_vars.v(), qp);

    libMesh::RealTensor hess_u = context.fixed_interior_hessian(this->_flow_vars.u(), qp);
    libMesh::RealTensor hess_v = context.fixed_interior_hessian(this->_flow_vars.v(), qp);

    libMesh::RealGradient rhoUdotGradU;
    libMesh::RealGradient divGradU;

    if( context.get_system().get_mesh().mesh_dimension() < 3 )
      {
        rhoUdotGradU = rho*this->UdotGradU( U, grad_u, grad_v );
        divGradU  = this->div_GradU( hess_u, hess_v );
      }
    else
      {
        libMesh::RealGradient grad_w = context.fixed_interior_gradient(this->_flow_vars.w(), qp);
        libMesh::RealTensor hess_w = context.fixed_interior_hessian(this->_flow_vars.w(), qp);

        rhoUdotGradU = rho*this->UdotGradU( U, grad_u, grad_v, grad_w );

        divGradU  = this->div_GradU( hess_u, hess_v, hess_w );

        d_res_M_dU(0,2) = rho * grad_u(2);
        d_res_M_dU(1,2) = rho * grad_v(2);

        d_res_Muvw_dgraduvw(2) = rho * U(2);
        d_res_M_dgradp(2,2) = 1;
        d_res_Muvw_dhessuvw(2,2) = mu;

        d_res_M_dU(2,0) = rho * grad_w(0);
        d_res_M_dU(2,1) = rho * grad_w(1);
        d_res_M_dU(2,2) = rho * grad_w(2);
      }

    res_M = rhoUdotGradU + grad_p - mu*divGradU;

    d_res_M_dU(0,0) = rho * grad_u(0);
    d_res_M_dU(0,1) = rho * grad_u(1);
    d_res_M_dU(1,0) = rho * grad_v(0);
    d_res_M_dU(1,1) = rho * grad_v(1);

    d_res_Muvw_dgraduvw(0) = rho * U(0);
    d_res_Muvw_dgraduvw(1) = rho * U(1);

    d_res_M_dgradp(0,0) = 1;
    d_res_M_dgradp(1,1) = 1;

    d_res_Muvw_dhessuvw(0,0) = mu;
    d_res_Muvw_dhessuvw(1,1) = mu;
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::compute_res_momentum_transient	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho
	)		const

Definition at line 319 of file inc_navier_stokes_stab_helper.C.

References _flow_vars, GRINS::VelocityFEVariables::u(), and GRINS::VelocityFEVariables::v().

  {
    libMesh::RealGradient u_dot;
    context.interior_rate(this->_flow_vars.u(), qp, u_dot(0)); 
    context.interior_rate(this->_flow_vars.v(), qp, u_dot(1));
    if(context.get_system().get_mesh().mesh_dimension() == 3)
      context.interior_rate(this->_flow_vars.w(), qp, u_dot(2));

    return rho*u_dot;
  }

void GRINS::IncompressibleNavierStokesStabilizationHelper::compute_res_momentum_transient_and_derivs	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho,
		libMesh::RealGradient &	res_M,
		libMesh::Real &	d_res_Muvw_duvw
	)		const

Definition at line 332 of file inc_navier_stokes_stab_helper.C.

  {
    libMesh::RealGradient u_dot;
    context.interior_rate(this->_flow_vars.u(), qp, u_dot(0)); 
    context.interior_rate(this->_flow_vars.v(), qp, u_dot(1));
    if(context.get_system().get_mesh().mesh_dimension() == 3)
      context.interior_rate(this->_flow_vars.w(), qp, u_dot(2));

    res_M = rho*u_dot;
    d_res_Muvw_duvw = rho;
  }

libMesh::Real GRINS::IncompressibleNavierStokesStabilizationHelper::compute_tau ( AssemblyContext &  c, unsigned int  qp, libMesh::Real  mat_prop_sq, libMesh::RealGradient &  g, libMesh::RealTensor &  G, libMesh::Real  rho, libMesh::Gradient  U, bool  is_steady  ) const

inline

Definition at line 250 of file inc_navier_stokes_stab_helper.h.

References _C, and _tau_factor.

Referenced by GRINS::LowMachNavierStokesStabilizationHelper::compute_tau_energy(), and compute_tau_momentum().

  {
    libMesh::Real tau = (rho*U)*(G*(rho*U)) + this->_C*mat_prop_sq*G.contract(G);
    
    if(!is_steady)
      tau += (2.0*rho/c.get_deltat_value())*(2.0*rho/c.get_deltat_value());

    return this->_tau_factor/std::sqrt(tau);
  }

void GRINS::IncompressibleNavierStokesStabilizationHelper::compute_tau_and_derivs ( AssemblyContext &  c, unsigned int  qp, libMesh::Real  mat_prop_sq, libMesh::RealGradient &  g, libMesh::RealTensor &  G, libMesh::Real  rho, libMesh::Gradient  U, libMesh::Real &  tau, libMesh::Real &  d_tau_d_rho, libMesh::Gradient &  d_tau_d_U, bool  is_steady  ) const

inline

Definition at line 270 of file inc_navier_stokes_stab_helper.h.

  {
    libMesh::Gradient rhoU = rho*U;
    libMesh::Gradient GrhoU = G*rhoU;
    libMesh::Real rhoUGrhoU = rhoU * GrhoU;
    libMesh::Real GG = G.contract(G);
    tau = rhoUGrhoU + this->_C*mat_prop_sq*GG;
    d_tau_d_rho = rhoUGrhoU*2/rho;
    d_tau_d_U = 2*rho*GrhoU;
    
    if(!is_steady)
      {
        libMesh::Real two_rho_over_dt = 2*rho/c.get_deltat_value();
        tau += two_rho_over_dt * two_rho_over_dt;
        d_tau_d_rho += 4*two_rho_over_dt/c.get_deltat_value();
      }

    // But what we've computed so far isn't tau; we need
    // tau = _tau_factor/ sqrt(our_tau)

    libMesh::Real root_oldtau = std::sqrt(tau);
    libMesh::Real d_tau_d_oldtau = -this->_tau_factor / (tau*root_oldtau) / 2;

    d_tau_d_rho         = d_tau_d_oldtau * d_tau_d_rho;
    d_tau_d_U           = d_tau_d_oldtau * d_tau_d_U;

    tau = this->_tau_factor / root_oldtau;
  }

libMesh::Real GRINS::IncompressibleNavierStokesStabilizationHelper::compute_tau_continuity ( libMesh::Real  tau_C, libMesh::RealGradient &  g  ) const

inline

Definition at line 193 of file inc_navier_stokes_stab_helper.h.

References _tau_factor.

  {
    return this->_tau_factor/(tau_M*(g*g));
  }

void GRINS::IncompressibleNavierStokesStabilizationHelper::compute_tau_continuity_and_derivs ( libMesh::Real  tau_M, libMesh::Real  d_tau_M_d_rho, libMesh::Gradient  d_tau_M_d_U, libMesh::RealGradient &  g, libMesh::Real &  tau_C, libMesh::Real &  d_tau_C_d_rho, libMesh::Gradient &  d_tau_C_d_U  ) const

inline

Definition at line 201 of file inc_navier_stokes_stab_helper.h.

  {
    tau_C = this->_tau_factor/(tau_M*(g*g));
    libMesh::Real d_tau_C_d_tau_M = -tau_C/tau_M;
    d_tau_C_d_rho = d_tau_C_d_tau_M * d_tau_M_d_rho;
    d_tau_C_d_U = d_tau_C_d_tau_M * d_tau_M_d_U;
  }

libMesh::Real GRINS::IncompressibleNavierStokesStabilizationHelper::compute_tau_momentum ( AssemblyContext &  c, unsigned int  qp, libMesh::RealGradient &  g, libMesh::RealTensor &  G, libMesh::Real  rho, libMesh::Gradient  U, libMesh::Real  mu, bool  is_steady  ) const

inline

Definition at line 217 of file inc_navier_stokes_stab_helper.h.

References compute_tau().

  {
    return this->compute_tau( c, qp, mu*mu, g, G, rho, U, is_steady );
  }

void GRINS::IncompressibleNavierStokesStabilizationHelper::compute_tau_momentum_and_derivs ( AssemblyContext &  c, unsigned int  qp, libMesh::RealGradient &  g, libMesh::RealTensor &  G, libMesh::Real  rho, libMesh::Gradient  U, libMesh::Real  T, libMesh::Real &  tau_M, libMesh::Real &  d_tau_M_d_rho, libMesh::Gradient &  d_tau_M_d_U, bool  is_steady  ) const

inline

Definition at line 231 of file inc_navier_stokes_stab_helper.h.

  {
    this->compute_tau_and_derivs( c, qp, mu*mu, g, G, rho, U, tau_M,
                                  d_tau_M_d_rho, d_tau_M_d_U,
                                  is_steady );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_divU_I	(	libMesh::RealTensor &	hess_u,
		libMesh::RealTensor &	hess_v
	)		const

Todo:

Should we inline this?

Definition at line 142 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_v(1,0),
                                  hess_u(0,1) + hess_v(1,1) );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_divU_I	(	libMesh::RealTensor &	hess_u,
		libMesh::RealTensor &	hess_v,
		libMesh::RealTensor &	hess_w
	)		const

Todo:

Should we inline this?

Definition at line 159 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_v(1,0) + hess_w(2,0),
                                  hess_u(0,1) + hess_v(1,1) + hess_w(2,1),
                                  hess_u(0,2) + hess_v(1,2) + hess_w(2,2) );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_divU_I_axi	(	libMesh::Real	r,
		const libMesh::Gradient &	U,
		const libMesh::Gradient &	grad_u,
		const libMesh::RealTensor &	hess_u,
		const libMesh::RealTensor &	hess_v
	)		const

Definition at line 149 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_v(1,0) + (grad_u(0) - U(0)/r)/r,
                                  hess_u(0,1) + hess_v(1,1) + grad_u(1)/r );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_GradU	(	libMesh::RealTensor &	hess_u,
		libMesh::RealTensor &	hess_v
	)		const

Todo:

Should we inline this?

Definition at line 89 of file inc_navier_stokes_stab_helper.C.

Referenced by compute_res_momentum_steady().

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_u(1,1),
                                  hess_v(0,0) + hess_v(1,1) );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_GradU	(	libMesh::RealTensor &	hess_u,
		libMesh::RealTensor &	hess_v,
		libMesh::RealTensor &	hess_w
	)		const

Todo:

Should we inline this?

Definition at line 107 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_u(1,1) + hess_u(2,2),
                                  hess_v(0,0) + hess_v(1,1) + hess_v(2,2),
                                  hess_w(0,0) + hess_w(1,1) + hess_w(2,2) );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_GradU_axi	(	libMesh::Real	r,
		const libMesh::Gradient &	U,
		const libMesh::Gradient &	grad_u,
		const libMesh::Gradient &	grad_v,
		const libMesh::RealTensor &	hess_u,
		const libMesh::RealTensor &	hess_v
	)		const

Definition at line 96 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_u(1,1) + (grad_u(0) - U(0)/r)/r,
                                  hess_v(0,0) + hess_v(1,1) + grad_v(0)/r );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_GradU_T	(	libMesh::RealTensor &	hess_u,
		libMesh::RealTensor &	hess_v
	)		const

Todo:

Should we inline this?

Definition at line 116 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_v(0,1),
                                  hess_u(1,0) + hess_v(1,1));
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_GradU_T	(	libMesh::RealTensor &	hess_u,
		libMesh::RealTensor &	hess_v,
		libMesh::RealTensor &	hess_w
	)		const

Todo:

Should we inline this?

Definition at line 133 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_v(0,1) + hess_w(0,2),
                                  hess_u(1,0) + hess_v(1,1) + hess_w(1,2),
                                  hess_u(2,0) + hess_v(2,1) + hess_w(2,2) );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::div_GradU_T_axi	(	libMesh::Real	r,
		const libMesh::Gradient &	U,
		const libMesh::Gradient &	grad_u,
		const libMesh::RealTensor &	hess_u,
		const libMesh::RealTensor &	hess_v
	)		const

Definition at line 123 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( hess_u(0,0) + hess_v(0,1) + (grad_u(0) - U(0)/r)/r,
                                  hess_u(1,0) + hess_v(1,1) + grad_u(1)/r );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::UdotGradU	(	libMesh::Gradient &	U,
		libMesh::Gradient &	grad_u,
		libMesh::Gradient &	grad_v
	)		const

Todo:

Should we inline this?

Definition at line 74 of file inc_navier_stokes_stab_helper.C.

Referenced by compute_res_momentum_steady().

  {
    return libMesh::RealGradient( U*grad_u, U*grad_v );
  }

libMesh::RealGradient GRINS::IncompressibleNavierStokesStabilizationHelper::UdotGradU	(	libMesh::Gradient &	U,
		libMesh::Gradient &	grad_u,
		libMesh::Gradient &	grad_v,
		libMesh::Gradient &	grad_w
	)		const

Todo:

Should we inline this?

Definition at line 81 of file inc_navier_stokes_stab_helper.C.

  {
    return libMesh::RealGradient( U*grad_u, U*grad_v, U*grad_w );
  }

Member Data Documentation

libMesh::Real GRINS::IncompressibleNavierStokesStabilizationHelper::_C

protected

Definition at line 183 of file inc_navier_stokes_stab_helper.h.

Referenced by compute_tau().

const VelocityFEVariables& GRINS::IncompressibleNavierStokesStabilizationHelper::_flow_vars

protected

Definition at line 185 of file inc_navier_stokes_stab_helper.h.

Referenced by compute_res_continuity(), compute_res_momentum_steady(), and compute_res_momentum_transient().

const PressureFEVariable& GRINS::IncompressibleNavierStokesStabilizationHelper::_press_var

protected

Definition at line 186 of file inc_navier_stokes_stab_helper.h.

Referenced by compute_res_momentum_steady().

libMesh::Real GRINS::IncompressibleNavierStokesStabilizationHelper::_tau_factor

protected

Definition at line 183 of file inc_navier_stokes_stab_helper.h.

Referenced by compute_tau(), and compute_tau_continuity().

---

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

• src/physics/include/grins/inc_navier_stokes_stab_helper.h
• src/physics/src/inc_navier_stokes_stab_helper.C