Adds Boussinesq bouyancy SPGSM stabilization source term. More...

#include <boussinesq_buoyancy_spgsm_stab.h>

Inheritance diagram for GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >:

Collaboration diagram for GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >:

[legend]

Public Member Functions
	BoussinesqBuoyancySPGSMStabilization (const std::string &physics_name, const GetPot &input)

	~BoussinesqBuoyancySPGSMStabilization ()

virtual void	element_time_derivative (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Time dependent part(s) of physics for element interiors. More...

virtual void	element_constraint (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Constraint part(s) of physics for element interiors. More...

virtual void	mass_residual (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Mass matrix part(s) for element interiors. All boundary terms lie within the time_derivative part. 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...

Public Member Functions inherited from GRINS::BoussinesqBuoyancyBase
	BoussinesqBuoyancyBase (const std::string &physics_name, const GetPot &input)

	~BoussinesqBuoyancyBase ()

virtual void	init_variables (libMesh::FEMSystem *system)
	Initialization of BoussinesqBuoyancy variables. More...

Public Member Functions inherited from GRINS::Physics
	Physics (const GRINS::PhysicsName &physics_name, const GetPot &input)

virtual	~Physics ()

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	set_time_evolving_vars (libMesh::FEMSystem *system)
	Set which variables are time evolving. 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	init_context (AssemblyContext &context)
	Initialize context for added physics variables. More...

virtual void	side_time_derivative (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Time dependent part(s) of physics for boundaries of elements on the domain boundary. More...

virtual void	nonlocal_time_derivative (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Time dependent part(s) of physics for scalar variables. More...

virtual void	side_constraint (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Constraint part(s) of physics for boundaries of elements on the domain boundary. More...

virtual void	nonlocal_constraint (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Constraint part(s) of physics for scalar variables. More...

virtual void	damping_residual (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Damping matrix part(s) for element interiors. All boundary terms lie within the time_derivative part. More...

virtual void	nonlocal_mass_residual (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	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 (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_side_time_derivative_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_nonlocal_time_derivative_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_element_constraint_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_side_constraint_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_nonlocal_constraint_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_damping_residual_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_mass_residual_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_nonlocal_mass_residual_cache (const AssemblyContext &context, CachedValues &cache)

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	_flow_stab_helper

HeatTransferStabilizationHelper	_temp_stab_helper

libMesh::Number	_Cp

libMesh::Number	_k

Viscosity	_mu
	Viscosity object. More...

Protected Attributes inherited from GRINS::BoussinesqBuoyancyBase
VelocityFEVariables	_flow_vars

PressureFEVariable	_press_var

PrimitiveTempFEVariables	_temp_vars

libMesh::Number	_rho
	$\rho =$ density More...

libMesh::Number	_T_ref
	reference temperature More...

libMesh::Number	_beta_T
	$\beta_T =$ coefficient of thermal expansion More...

libMesh::Point	_g
	Gravitational vector. More...

unsigned int	_dim
	Physical dimension of problem. 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
	BoussinesqBuoyancySPGSMStabilization ()

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::BoussinesqBuoyancyBase
void	read_property (const GetPot &input, const std::string &old_option, const std::string &property, libMesh::Real &value)
	Helper function for parsing/maintaing backward compatibility. More...

void	no_input_warning (const GetPot &input, const std::string &old_option, const std::string &material, const std::string &property)
	Helper function for parsing/maintaing backward compatibility. 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)

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::BoussinesqBuoyancySPGSMStabilization< Viscosity >

Adds Boussinesq bouyancy SPGSM stabilization source term.

This class implements the SPGSM stabilization term for the BoussinesqBuoyancy Physics. Intended to be used with IncompressibleNavierStokesSPGSMStabilization and HeatTransferSPGSMStabilization. This, essentially, is just adding SUPG terms to the momentum equation and PSPG terms to the pressure equation.

Definition at line 45 of file boussinesq_buoyancy_spgsm_stab.h.

Constructor & Destructor Documentation

template<class Mu >

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

Definition at line 42 of file boussinesq_buoyancy_spgsm_stab.C.

References GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::_Cp, GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::_k, GRINS::PhysicsNaming::boussinesq_buoyancy(), GRINS::PhysicsNaming::heat_transfer(), GRINS::MaterialsParsing::read_specific_heat(), and GRINS::ParameterUser::set_parameter().

     : BoussinesqBuoyancyBase(physics_name,input),
       _flow_stab_helper(physics_name+"FlowStabHelper", input),
       _temp_stab_helper(physics_name+"TempStabHelper", input),
       _Cp(0.0),
       _k(1.0),
       _mu(input,MaterialsParsing::material_name(input,PhysicsNaming::boussinesq_buoyancy()))
   {
     MaterialsParsing::read_specific_heat( PhysicsNaming::boussinesq_buoyancy(), input, (*this), this->_Cp );
 
     this->set_parameter
       (_k, input, "Physics/"+PhysicsNaming::heat_transfer()+"/k", _k);
   }

template<class Mu >

GRINS::BoussinesqBuoyancySPGSMStabilization< Mu >::~BoussinesqBuoyancySPGSMStabilization ( )

Definition at line 57 of file boussinesq_buoyancy_spgsm_stab.C.

   {
     return;
   }

template<class Viscosity >

GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::BoussinesqBuoyancySPGSMStabilization ( )

private

Member Function Documentation

template<class Mu >

void GRINS::BoussinesqBuoyancySPGSMStabilization< Mu >::element_constraint	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

Constraint part(s) of physics for element interiors.

Reimplemented from GRINS::Physics.

Definition at line 162 of file boussinesq_buoyancy_spgsm_stab.C.

   {
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->BeginTimer("BoussinesqBuoyancySPGSMStabilization::element_constraint");
 #endif
 
     // The number of local degrees of freedom in each variable.
     const unsigned int n_p_dofs = context.get_dof_indices(_press_var.p()).size();
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(_flow_vars.u())->get_JxW();
 
     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}
 
     // 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->_flow_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_flow_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->_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 = this->_flow_stab_helper.compute_tau_momentum( context, qp, g, G, this->_rho, U, mu_qp, this->_is_steady );
 
         // Compute the solution & its gradient at the old Newton iterate.
         libMesh::Number T;
         T = context.interior_value(_temp_vars.T(), qp);
 
         libMesh::RealGradient residual = _rho*_beta_T*(T-_T_ref)*_g;
 
         // 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*residual*p_dphi[i][qp]*JxW[qp];
 
             if (compute_jacobian)
               {
                 libmesh_not_implemented();
               } // End compute_jacobian check
 
           } // End i dof loop
 
       } // End quadrature loop
 
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->EndTimer("BoussinesqBuoyancySPGSMStabilization::element_constraint");
 #endif
 
     return;
   }

template<class Mu >

void GRINS::BoussinesqBuoyancySPGSMStabilization< Mu >::element_time_derivative	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

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

Reimplemented from GRINS::Physics.

Definition at line 63 of file boussinesq_buoyancy_spgsm_stab.C.

   {
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->BeginTimer("BoussinesqBuoyancySPGSMStabilization::element_time_derivative");
 #endif
 
     // The number of local degrees of freedom in each variable.
     const unsigned int n_u_dofs = context.get_dof_indices(_flow_vars.u()).size();
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(_flow_vars.u())->get_JxW();
 
     /*
     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();
 
     // Get residuals
     libMesh::DenseSubVector<libMesh::Number> &Fu = context.get_elem_residual(_flow_vars.u()); // R_{u}
     libMesh::DenseSubVector<libMesh::Number> &Fv = context.get_elem_residual(_flow_vars.v()); // R_{v}
     libMesh::DenseSubVector<libMesh::Number> *Fw = NULL;
     if(this->_dim == 3)
       {
         Fw = &context.get_elem_residual(this->_flow_vars.w()); // R_{w}
       }
 
     // 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->_flow_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_flow_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->_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 = this->_flow_stab_helper.compute_tau_momentum( context, qp, g, G, this->_rho, U, mu_qp, this->_is_steady );
 
         //libMesh::Real tau_E = this->_temp_stab_helper.compute_tau_energy( context, G, _rho, _Cp, _k,  U, this->_is_steady );
 
         //libMesh::Real RE = this->_temp_stab_helper.compute_res_energy_steady( context, qp, _rho, _Cp, _k );
 
         // Compute the solution & its gradient at the old Newton iterate.
         libMesh::Number T;
         T = context.interior_value(_temp_vars.T(), qp);
 
         libMesh::RealGradient residual = _rho*_beta_T*(T-_T_ref)*_g;
 
         for (unsigned int i=0; i != n_u_dofs; i++)
           {
             Fu(i) += ( -tau_M*residual(0)*_rho*U*u_gradphi[i][qp] )*JxW[qp];
             // + _rho*_beta_T*tau_E*RE*_g(0)*u_phi[i][qp] )*JxW[qp];
 
             Fv(i) += ( -tau_M*residual(1)*_rho*U*u_gradphi[i][qp] )*JxW[qp];
             // + _rho*_beta_T*tau_E*RE*_g(1)*u_phi[i][qp] )*JxW[qp];
 
             if (_dim == 3)
               {
                 (*Fw)(i) += ( -tau_M*residual(2)*_rho*U*u_gradphi[i][qp] )*JxW[qp];
                 // + _rho*_beta_T*tau_E*RE*_g(2)*u_phi[i][qp] )*JxW[qp];
               }
 
             if (compute_jacobian)
               {
                 libmesh_not_implemented();
               } // End compute_jacobian check
 
           } // End i dof loop
       } // End quadrature loop
 
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->EndTimer("BoussinesqBuoyancySPGSMStabilization::element_time_derivative");
 #endif
 
     return;
   }

template<class Mu >

void GRINS::BoussinesqBuoyancySPGSMStabilization< Mu >::mass_residual	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

Mass matrix part(s) for element interiors. All boundary terms lie within the time_derivative part.

Reimplemented from GRINS::Physics.

Definition at line 239 of file boussinesq_buoyancy_spgsm_stab.C.

   {
     /*
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->BeginTimer("BoussinesqBuoyancySPGSMStabilization::mass_residual");
 #endif
 
     // The number of local degrees of freedom in each variable.
     const unsigned int n_u_dofs = context.get_dof_indices(_flow_vars.u()).size();
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(_flow_vars.u())->get_JxW();
 
     const std::vector<std::vector<libMesh::Real> >& u_phi =
       context.get_element_fe(this->_flow_vars.u())->get_phi();
 
     // Get residuals
     libMesh::DenseSubVector<libMesh::Number> &Fu = context.get_elem_residual(_flow_vars.u()); // R_{u}
     libMesh::DenseSubVector<libMesh::Number> &Fv = context.get_elem_residual(_flow_vars.v()); // R_{v}
     libMesh::DenseSubVector<libMesh::Number> *Fw = NULL;
     if(this->_dim == 3)
       {
         Fw = &context.get_elem_residual(this->_flow_vars.w()); // R_{w}
       }
 
     // 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->_flow_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_flow_stab_helper.compute_G( fe, context, qp );
 
         libMesh::RealGradient U( context.fixed_interior_value( this->_flow_vars.u(), qp ),
                                  context.fixed_interior_value( this->_flow_vars.v(), qp ) );
         if( this->_dim == 3 )
           {
             U(2) = context.fixed_interior_value( this->_flow_vars.w(), qp );
           }
 
         libMesh::Real tau_E = this->_temp_stab_helper.compute_tau_energy( context, G, _rho, _Cp, _k,  U, false );
 
         libMesh::Real RE = this->_temp_stab_helper.compute_res_energy_transient( context, qp, _rho, _Cp );
 
 
         for (unsigned int i=0; i != n_u_dofs; i++)
           {
             Fu(i) += -_rho*_beta_T*tau_E*RE*_g(0)*u_phi[i][qp]*JxW[qp];
 
             Fv(i) += -_rho*_beta_T*tau_E*RE*_g(1)*u_phi[i][qp]*JxW[qp];
 
             if (_dim == 3)
               {
                 (*Fw)(i) += -_rho*_beta_T*tau_E*RE*_g(2)*u_phi[i][qp]*JxW[qp];
               }
 
             if (compute_jacobian)
               {
                 libmesh_not_implemented();
               } // End compute_jacobian check
 
           } // End i dof loop
       } // End quadrature loop
 
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->EndTimer("BoussinesqBuoyancySPGSMStabilization::mass_residual");
 #endif
     */
 
     return;
   }

template<class Mu >

void GRINS::BoussinesqBuoyancySPGSMStabilization< Mu >::register_parameter	(	const std::string &	param_name,
		libMesh::ParameterMultiAccessor< libMesh::Number > &	param_pointer
	)		const

virtual

Each subclass will register its copy of an independent.

Reimplemented from GRINS::ParameterUser.

Definition at line 323 of file boussinesq_buoyancy_spgsm_stab.C.

References GRINS::ParameterUser::register_parameter().

   {
     ParameterUser::register_parameter(param_name, param_pointer);
     _mu.register_parameter(param_name, param_pointer);
   }

Member Data Documentation

template<class Viscosity >

libMesh::Number GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::_Cp

protected

Definition at line 79 of file boussinesq_buoyancy_spgsm_stab.h.

Referenced by GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::BoussinesqBuoyancySPGSMStabilization().

template<class Viscosity >

IncompressibleNavierStokesStabilizationHelper GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::_flow_stab_helper

protected

Definition at line 76 of file boussinesq_buoyancy_spgsm_stab.h.

template<class Viscosity >

libMesh::Number GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::_k

protected

Definition at line 79 of file boussinesq_buoyancy_spgsm_stab.h.

Referenced by GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::BoussinesqBuoyancySPGSMStabilization().

template<class Viscosity >

Viscosity GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::_mu

protected

Viscosity object.

Definition at line 82 of file boussinesq_buoyancy_spgsm_stab.h.

template<class Viscosity >

HeatTransferStabilizationHelper GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::_temp_stab_helper

protected

Definition at line 77 of file boussinesq_buoyancy_spgsm_stab.h.

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

src/physics/include/grins/boussinesq_buoyancy_spgsm_stab.h
src/physics/src/boussinesq_buoyancy_spgsm_stab.C

Public Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

template<class Viscosity> class GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class Viscosity>
class GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >