GRINS::VelocityPenaltyAdjointStabilization< Viscosity > Class Template Reference

Adds Velocity penalty adjoint stabilization source term. More...

#include <velocity_penalty_adjoint_stab.h>

Inheritance diagram for GRINS::VelocityPenaltyAdjointStabilization< Viscosity >:

Collaboration diagram for GRINS::VelocityPenaltyAdjointStabilization< Viscosity >:

Public Member Functions
	VelocityPenaltyAdjointStabilization (const std::string &physics_name, const GetPot &input)
	~VelocityPenaltyAdjointStabilization ()
virtual void	init_context (AssemblyContext &context)
	Initialize context for added physics variables. More...
virtual void	element_time_derivative (bool compute_jacobian, AssemblyContext &context)
	Time dependent part(s) of physics for element interiors. More...
virtual void	element_constraint (bool compute_jacobian, AssemblyContext &context)
	Constraint part(s) of physics for element interiors. More...
Public Member Functions inherited from GRINS::VelocityPenaltyBase< Viscosity >
	VelocityPenaltyBase (const std::string &physics_name, const GetPot &input)
	~VelocityPenaltyBase ()
void	set_time_evolving_vars (libMesh::FEMSystem *system)
	Sets velocity variables to be time-evolving. More...
bool	compute_force (const libMesh::Point &point, const AssemblyContext &context, const libMesh::NumberVectorValue &U, libMesh::NumberVectorValue &F, libMesh::NumberTensorValue *dFdU=NULL)
Public Member Functions inherited from GRINS::IncompressibleNavierStokesBase< Viscosity >
	IncompressibleNavierStokesBase (const std::string &my_physics_name, const std::string &core_physics_name, const GetPot &input)
	~IncompressibleNavierStokesBase ()
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...
libMesh::Real	get_viscosity_value (AssemblyContext &context, unsigned int qp) const
Public Member Functions inherited from GRINS::Physics
	Physics (const GRINS::PhysicsName &physics_name, const GetPot &input)
virtual	~Physics ()
virtual void	init_variables (libMesh::FEMSystem *)
	Initialize variables for this physics. More...
virtual bool	enabled_on_elem (const libMesh::Elem *elem)
	Find if current physics is active on supplied element. More...
void	set_is_steady (bool is_steady)
	Sets whether this physics is to be solved with a steady solver or not. More...
bool	is_steady () const
	Returns whether or not this physics is being solved with a steady solver. More...
virtual void	auxiliary_init (MultiphysicsSystem &system)
	Any auxillary initialization a Physics class may need. More...
virtual void	register_postprocessing_vars (const GetPot &input, PostProcessedQuantities< libMesh::Real > &postprocessing)
	Register name of postprocessed quantity with PostProcessedQuantities. More...
virtual void	preassembly (MultiphysicsSystem &)
	Perform any necessary setup before element assembly begins. More...
virtual void	reinit (MultiphysicsSystem &)
	Any reinitialization that needs to be done. More...
virtual void	side_time_derivative (bool, AssemblyContext &)
	Time dependent part(s) of physics for boundaries of elements on the domain boundary. More...
virtual void	nonlocal_time_derivative (bool, AssemblyContext &)
	Time dependent part(s) of physics for scalar variables. More...
virtual void	side_constraint (bool, AssemblyContext &)
	Constraint part(s) of physics for boundaries of elements on the domain boundary. More...
virtual void	nonlocal_constraint (bool, AssemblyContext &)
	Constraint part(s) of physics for scalar variables. More...
virtual void	damping_residual (bool, AssemblyContext &)
	Damping matrix part(s) for element interiors. All boundary terms lie within the time_derivative part. More...
virtual void	mass_residual (bool, AssemblyContext &)
	Mass matrix part(s) for element interiors. All boundary terms lie within the time_derivative part. More...
virtual void	nonlocal_mass_residual (bool, AssemblyContext &)
	Mass matrix part(s) for scalar variables. More...
void	init_ics (libMesh::FEMSystem *system, libMesh::CompositeFunction< libMesh::Number > &all_ics)
virtual void	compute_element_time_derivative_cache (AssemblyContext &)
virtual void	compute_side_time_derivative_cache (AssemblyContext &)
virtual void	compute_nonlocal_time_derivative_cache (AssemblyContext &)
virtual void	compute_element_constraint_cache (AssemblyContext &)
virtual void	compute_side_constraint_cache (AssemblyContext &)
virtual void	compute_nonlocal_constraint_cache (AssemblyContext &)
virtual void	compute_damping_residual_cache (AssemblyContext &)
virtual void	compute_mass_residual_cache (AssemblyContext &)
virtual void	compute_nonlocal_mass_residual_cache (AssemblyContext &)
virtual void	compute_postprocessed_quantity (unsigned int quantity_index, const AssemblyContext &context, const libMesh::Point &point, libMesh::Real &value)
ICHandlingBase *	get_ic_handler ()
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...

Protected Attributes
IncompressibleNavierStokesStabilizationHelper	_stab_helper
Protected Attributes inherited from GRINS::VelocityPenaltyBase< Viscosity >
std::string	base_physics_name
bool	_quadratic_scaling
libMesh::UniquePtr< libMesh::FEMFunctionBase< libMesh::Number > >	normal_vector_function
libMesh::UniquePtr< libMesh::FEMFunctionBase< libMesh::Number > >	base_velocity_function
Protected Attributes inherited from GRINS::IncompressibleNavierStokesBase< Viscosity >
VelocityVariable &	_flow_vars
PressureFEVariable &	_press_var
libMesh::Number	_rho
	Material parameters, read from input. More...
Viscosity	_mu
	Viscosity object. More...
Protected Attributes inherited from GRINS::Physics
const PhysicsName	_physics_name
	Name of the physics object. Used for reading physics specific inputs. More...
GRINS::ICHandlingBase *	_ic_handler
std::set< libMesh::subdomain_id_type >	_enabled_subdomains
	Subdomains on which the current Physics class is enabled. More...

Private Member Functions
	VelocityPenaltyAdjointStabilization ()

Additional Inherited Members
Static Public Member Functions inherited from GRINS::Physics
static void	set_is_axisymmetric (bool is_axisymmetric)
	Set whether we should treat the problem as axisymmetric. More...
static bool	is_axisymmetric ()
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...
Protected Member Functions inherited from GRINS::Physics
libMesh::UniquePtr< libMesh::FEGenericBase< libMesh::Real > >	build_new_fe (const libMesh::Elem *elem, const libMesh::FEGenericBase< libMesh::Real > *fe, const libMesh::Point p)
void	parse_enabled_subdomains (const GetPot &input, const std::string &physics_name)
void	check_var_subdomain_consistency (const FEVariablesBase &var) const
	Check that var is enabled on at least the subdomains this Physics is. More...
Static Protected Attributes inherited from GRINS::Physics
static bool	_is_steady = false
	Caches whether or not the solver that's being used is steady or not. More...
static bool	_is_axisymmetric = false
	Caches whether we are solving an axisymmetric problem or not. More...

Detailed Description

template<class Viscosity>
class GRINS::VelocityPenaltyAdjointStabilization< Viscosity >

Adds Velocity penalty adjoint stabilization source term.

This class implements the adjoint stabilization term for the VelocityPenalty Physics. Intended to be used with IncompressibleNavierStokesAdjointStabilization.

Definition at line 42 of file velocity_penalty_adjoint_stab.h.

Constructor & Destructor Documentation

template<class Mu >

GRINS::VelocityPenaltyAdjointStabilization< Mu >::VelocityPenaltyAdjointStabilization	(	const std::string &	physics_name,
		const GetPot &	input
	)

Definition at line 42 of file velocity_penalty_adjoint_stab.C.

    : VelocityPenaltyBase<Mu>(physics_name,input),
    _stab_helper( physics_name+"StabHelper", input )
  {
  }

template<class Mu >

GRINS::VelocityPenaltyAdjointStabilization< Mu >::~VelocityPenaltyAdjointStabilization

(

)

Definition at line 49 of file velocity_penalty_adjoint_stab.C.

  {
    return;
  }

template<class Viscosity >

GRINS::VelocityPenaltyAdjointStabilization< Viscosity >::VelocityPenaltyAdjointStabilization ( )

private

Member Function Documentation

template<class Mu >

void GRINS::VelocityPenaltyAdjointStabilization< Mu >::element_constraint ( bool  , AssemblyContext &    )

virtual

Constraint part(s) of physics for element interiors.

Reimplemented from GRINS::Physics.

Definition at line 235 of file velocity_penalty_adjoint_stab.C.

  {
    // The number of local degrees of freedom in each variable.
    const unsigned int n_p_dofs = context.get_dof_indices(this->_press_var.p()).size();
    const unsigned int n_u_dofs = context.get_dof_indices(this->_flow_vars.u()).size();

    // Element Jacobian * quadrature weights for interior integration.
    const std::vector<libMesh::Real> &JxW =
      context.get_element_fe(this->_flow_vars.u())->get_JxW();

    const std::vector<libMesh::Point>& u_qpoint =
      context.get_element_fe(this->_flow_vars.u())->get_xyz();

    const std::vector<std::vector<libMesh::Real> >& u_phi =
      context.get_element_fe(this->_flow_vars.u())->get_phi();

    const std::vector<std::vector<libMesh::RealGradient> >& p_dphi =
      context.get_element_fe(this->_press_var.p())->get_dphi();

    libMesh::DenseSubVector<libMesh::Number> &Fp = context.get_elem_residual(this->_press_var.p()); // R_{p}

    libMesh::DenseSubMatrix<libMesh::Number> &Kpu =
      context.get_elem_jacobian(this->_press_var.p(), this->_flow_vars.u()); // J_{pu}
    libMesh::DenseSubMatrix<libMesh::Number> &Kpv =
      context.get_elem_jacobian(this->_press_var.p(), this->_flow_vars.v()); // J_{pv}
    libMesh::DenseSubMatrix<libMesh::Number> *Kpw = NULL;

    if(this->_flow_vars.dim() == 3)
      {
        Kpw = &context.get_elem_jacobian
          (this->_press_var.p(), this->_flow_vars.w()); // J_{pw}
      }

    // Now we will build the element Jacobian and residual.
    // Constructing the residual requires the solution and its
    // gradient from the previous timestep.  This must be
    // calculated at each quadrature point by summing the
    // solution degree-of-freedom values by the appropriate
    // weight functions.
    unsigned int n_qpoints = context.get_element_qrule().n_points();

    libMesh::FEBase* fe = context.get_element_fe(this->_flow_vars.u());

    for (unsigned int qp=0; qp != n_qpoints; qp++)
      {
        libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
        libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );

        libMesh::RealGradient U( context.interior_value( this->_flow_vars.u(), qp ),
                                 context.interior_value( this->_flow_vars.v(), qp ) );
        if( this->_flow_vars.dim() == 3 )
          {
            U(2) = context.interior_value( this->_flow_vars.w(), qp );
          }

        // Compute the viscosity at this qp
        libMesh::Real mu_qp = this->_mu(context, qp);

        libMesh::Real tau_M;
        libMesh::Real d_tau_M_d_rho;
        libMesh::Gradient d_tau_M_dU;

        if (compute_jacobian)
          this->_stab_helper.compute_tau_momentum_and_derivs
            ( context, qp, g, G, this->_rho, U, mu_qp,
              tau_M, d_tau_M_d_rho, d_tau_M_dU,
              this->_is_steady );
        else
          tau_M = this->_stab_helper.compute_tau_momentum
            ( context, qp, g, G, this->_rho, U, mu_qp,
              this->_is_steady );

        libMesh::NumberVectorValue F;
        libMesh::NumberTensorValue dFdU;
        libMesh::NumberTensorValue* dFdU_ptr =
          compute_jacobian ? &dFdU : NULL;
        if (!this->compute_force(u_qpoint[qp], context, U, F, dFdU_ptr))
          continue;

        // First, an i-loop over the velocity degrees of freedom.
        // We know that n_u_dofs == n_v_dofs so we can compute contributions
        // for both at the same time.
        for (unsigned int i=0; i != n_p_dofs; i++)
          {
            Fp(i) += -tau_M*F*p_dphi[i][qp]*JxW[qp];

            if (compute_jacobian)
              {
                for (unsigned int j=0; j != n_u_dofs; ++j)
                  {
                    Kpu(i,j) += -d_tau_M_dU(0)*u_phi[j][qp]*F*p_dphi[i][qp]*JxW[qp]*context.get_elem_solution_derivative();
                    Kpv(i,j) += -d_tau_M_dU(1)*u_phi[j][qp]*F*p_dphi[i][qp]*JxW[qp]*context.get_elem_solution_derivative();
                    for (unsigned int d=0; d != 3; ++d)
                      {
                        Kpu(i,j) += -tau_M*dFdU(d,0)*u_phi[j][qp]*p_dphi[i][qp](d)*JxW[qp]*context.get_elem_solution_derivative();
                        Kpv(i,j) += -tau_M*dFdU(d,1)*u_phi[j][qp]*p_dphi[i][qp](d)*JxW[qp]*context.get_elem_solution_derivative();
                      }
                  }
                if( this->_flow_vars.dim() == 3 )
                  for (unsigned int j=0; j != n_u_dofs; ++j)
                    {
                      (*Kpw)(i,j) += -d_tau_M_dU(2)*u_phi[j][qp]*F*p_dphi[i][qp]*JxW[qp]*context.get_elem_solution_derivative();
                      for (unsigned int d=0; d != 3; ++d)
                        {
                          (*Kpw)(i,j) += -tau_M*dFdU(d,2)*u_phi[j][qp]*p_dphi[i][qp](d)*JxW[qp]*context.get_elem_solution_derivative();
                        }
                    }
              }
          }
      } // End quadrature loop
  }

template<class Mu >

void GRINS::VelocityPenaltyAdjointStabilization< Mu >::element_time_derivative ( bool  , AssemblyContext &    )

virtual

Time dependent part(s) of physics for element interiors.

Reimplemented from GRINS::Physics.

Definition at line 69 of file velocity_penalty_adjoint_stab.C.

  {
    // The number of local degrees of freedom in each variable.
    const unsigned int n_u_dofs = context.get_dof_indices(this->_flow_vars.u()).size();

    // Element Jacobian * quadrature weights for interior integration.
    const std::vector<libMesh::Real> &JxW =
      context.get_element_fe(this->_flow_vars.u())->get_JxW();

    const std::vector<libMesh::Point>& u_qpoint =
      context.get_element_fe(this->_flow_vars.u())->get_xyz();

    const std::vector<std::vector<libMesh::Real> >& u_phi =
      context.get_element_fe(this->_flow_vars.u())->get_phi();

    const std::vector<std::vector<libMesh::RealGradient> >& u_gradphi =
      context.get_element_fe(this->_flow_vars.u())->get_dphi();

    const std::vector<std::vector<libMesh::RealTensor> >& u_hessphi =
      context.get_element_fe(this->_flow_vars.u())->get_d2phi();

    // Get residuals and jacobians
    libMesh::DenseSubVector<libMesh::Number> &Fu = context.get_elem_residual(this->_flow_vars.u()); // R_{u}
    libMesh::DenseSubVector<libMesh::Number> &Fv = context.get_elem_residual(this->_flow_vars.v()); // R_{v}
    libMesh::DenseSubVector<libMesh::Number> *Fw = NULL;

    libMesh::DenseSubMatrix<libMesh::Number> &Kuu =
      context.get_elem_jacobian(this->_flow_vars.u(), this->_flow_vars.u()); // J_{uu}
    libMesh::DenseSubMatrix<libMesh::Number> &Kuv =
      context.get_elem_jacobian(this->_flow_vars.u(), this->_flow_vars.v()); // J_{uv}
    libMesh::DenseSubMatrix<libMesh::Number> &Kvu =
      context.get_elem_jacobian(this->_flow_vars.v(), this->_flow_vars.u()); // J_{vu}
    libMesh::DenseSubMatrix<libMesh::Number> &Kvv =
      context.get_elem_jacobian(this->_flow_vars.v(), this->_flow_vars.v()); // J_{vv}

    libMesh::DenseSubMatrix<libMesh::Number> *Kuw = NULL;
    libMesh::DenseSubMatrix<libMesh::Number> *Kvw = NULL;
    libMesh::DenseSubMatrix<libMesh::Number> *Kwu = NULL;
    libMesh::DenseSubMatrix<libMesh::Number> *Kwv = NULL;
    libMesh::DenseSubMatrix<libMesh::Number> *Kww = NULL;

    if(this->_flow_vars.dim() == 3)
      {
        Fw = &context.get_elem_residual(this->_flow_vars.w()); // R_{w}
        Kuw = &context.get_elem_jacobian
          (this->_flow_vars.u(), this->_flow_vars.w()); // J_{uw}
        Kvw = &context.get_elem_jacobian
          (this->_flow_vars.v(), this->_flow_vars.w()); // J_{vw}
        Kwu = &context.get_elem_jacobian
          (this->_flow_vars.w(), this->_flow_vars.u()); // J_{wu}
        Kwv = &context.get_elem_jacobian
          (this->_flow_vars.w(), this->_flow_vars.v()); // J_{wv}
        Kww = &context.get_elem_jacobian
          (this->_flow_vars.w(), this->_flow_vars.w()); // J_{ww}
      }

    // Now we will build the element Jacobian and residual.
    // Constructing the residual requires the solution and its
    // gradient from the previous timestep.  This must be
    // calculated at each quadrature point by summing the
    // solution degree-of-freedom values by the appropriate
    // weight functions.
    unsigned int n_qpoints = context.get_element_qrule().n_points();

    libMesh::FEBase* fe = context.get_element_fe(this->_flow_vars.u());

    for (unsigned int qp=0; qp != n_qpoints; qp++)
      {
        libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
        libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );

        libMesh::RealGradient U( context.interior_value( this->_flow_vars.u(), qp ),
                                 context.interior_value( this->_flow_vars.v(), qp ) );
        if( this->_flow_vars.dim() == 3 )
          {
            U(2) = context.interior_value( this->_flow_vars.w(), qp );
          }

        // Compute the viscosity at this qp
        libMesh::Real mu_qp = this->_mu(context, qp);

        libMesh::Real tau_M;
        libMesh::Real d_tau_M_d_rho;
        libMesh::Gradient d_tau_M_dU;

        if (compute_jacobian)
          this->_stab_helper.compute_tau_momentum_and_derivs
            ( context, qp, g, G, this->_rho, U, mu_qp,
              tau_M, d_tau_M_d_rho, d_tau_M_dU,
              this->_is_steady );
        else
          tau_M = this->_stab_helper.compute_tau_momentum
            ( context, qp, g, G, this->_rho, U, mu_qp,
              this->_is_steady );

        libMesh::NumberVectorValue F;
        libMesh::NumberTensorValue dFdU;
        libMesh::NumberTensorValue* dFdU_ptr =
          compute_jacobian ? &dFdU : NULL;
        if (!this->compute_force(u_qpoint[qp], context, U, F, dFdU_ptr))
          continue;

        for (unsigned int i=0; i != n_u_dofs; i++)
          {
            libMesh::Real test_func = this->_rho*U*u_gradphi[i][qp] +
              mu_qp*( u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,1) + u_hessphi[i][qp](2,2) );
            Fu(i) += tau_M*F(0)*test_func*JxW[qp];

            Fv(i) += tau_M*F(1)*test_func*JxW[qp];

            if (this->_flow_vars.dim() == 3)
              {
                (*Fw)(i) += tau_M*F(2)*test_func*JxW[qp];
              }

            if (compute_jacobian)
              {
                libMesh::Gradient d_test_func_dU = this->_rho*u_gradphi[i][qp];

                for (unsigned int j=0; j != n_u_dofs; ++j)
                  {
                    Kuu(i,j) += tau_M*F(0)*d_test_func_dU(0)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                    Kuu(i,j) += d_tau_M_dU(0)*u_phi[j][qp]*F(0)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                    Kuu(i,j) += tau_M*dFdU(0,0)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                    Kuv(i,j) += tau_M*F(0)*d_test_func_dU(1)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                    Kuv(i,j) += d_tau_M_dU(1)*u_phi[j][qp]*F(0)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                    Kuv(i,j) += tau_M*dFdU(0,1)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                    Kvu(i,j) += tau_M*F(1)*d_test_func_dU(0)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                    Kvu(i,j) += d_tau_M_dU(0)*u_phi[j][qp]*F(1)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                    Kvu(i,j) += tau_M*dFdU(1,0)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                    Kvv(i,j) += tau_M*F(1)*d_test_func_dU(1)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                    Kvv(i,j) += d_tau_M_dU(1)*u_phi[j][qp]*F(1)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                    Kvv(i,j) += tau_M*dFdU(1,1)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                  }

                if (this->_flow_vars.dim() == 3)
                  {
                    for (unsigned int j=0; j != n_u_dofs; ++j)
                      {
                        (*Kuw)(i,j) += tau_M*F(0)*d_test_func_dU(2)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kuw)(i,j) += d_tau_M_dU(2)*u_phi[j][qp]*F(0)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kuw)(i,j) += tau_M*dFdU(0,2)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kvw)(i,j) += tau_M*F(1)*d_test_func_dU(2)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kvw)(i,j) += d_tau_M_dU(2)*u_phi[j][qp]*F(1)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kvw)(i,j) += tau_M*dFdU(1,2)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kwu)(i,j) += tau_M*F(2)*d_test_func_dU(0)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kwu)(i,j) += d_tau_M_dU(0)*u_phi[j][qp]*F(2)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kwu)(i,j) += tau_M*dFdU(2,0)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kwv)(i,j) += tau_M*F(2)*d_test_func_dU(1)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kwv)(i,j) += d_tau_M_dU(1)*u_phi[j][qp]*F(2)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kwv)(i,j) += tau_M*dFdU(2,1)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kww)(i,j) += tau_M*F(2)*d_test_func_dU(2)*u_phi[j][qp]*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kww)(i,j) += d_tau_M_dU(2)*u_phi[j][qp]*F(2)*test_func*JxW[qp]*context.get_elem_solution_derivative();
                        (*Kww)(i,j) += tau_M*dFdU(2,2)*u_phi[j][qp]*test_func*JxW[qp]*context.get_elem_solution_derivative();
                      }
                  }

              } // End compute_jacobian check

          } // End i dof loop
      } // End quadrature loop
  }

template<class Mu >

void GRINS::VelocityPenaltyAdjointStabilization< Mu >::init_context ( AssemblyContext &  context )

virtual

Initialize context for added physics variables.

Reimplemented from GRINS::IncompressibleNavierStokesBase< Viscosity >.

Definition at line 55 of file velocity_penalty_adjoint_stab.C.

  {
    context.get_element_fe(this->_press_var.p())->get_dphi();

    context.get_element_fe(this->_flow_vars.u())->get_xyz();
    context.get_element_fe(this->_flow_vars.u())->get_phi();
    context.get_element_fe(this->_flow_vars.u())->get_dphi();
    context.get_element_fe(this->_flow_vars.u())->get_d2phi();

    return;
  }

Member Data Documentation

template<class Viscosity >

IncompressibleNavierStokesStabilizationHelper GRINS::VelocityPenaltyAdjointStabilization< Viscosity >::_stab_helper

protected

Definition at line 60 of file velocity_penalty_adjoint_stab.h.

---

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

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