#include <spalart_allmaras_stab_helper.h>

Inheritance diagram for GRINS::SpalartAllmarasStabilizationHelper:

Collaboration diagram for GRINS::SpalartAllmarasStabilizationHelper:

Public Member Functions
	SpalartAllmarasStabilizationHelper (const std::string &helper_name, const GetPot &input)

	~SpalartAllmarasStabilizationHelper ()

void	init (libMesh::FEMSystem &system)

libMesh::Real	compute_tau_spalart (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_spalart_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_spalart_steady (AssemblyContext &context, unsigned int qp, const libMesh::Real rho, const libMesh::Real mu, const libMesh::Real distance_qp) const

void	compute_res_spalart_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::Real	compute_res_spalart_transient (AssemblyContext &context, unsigned int qp, const libMesh::Real rho) const

void	compute_res_spalart_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	compute_g (libMesh::FEBase *fe, AssemblyContext &c, unsigned int qp) const

libMesh::RealTensor	compute_G (libMesh::FEBase *fe, AssemblyContext &c, unsigned int qp) const

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	register_parameter (const std::string &param_name, libMesh::ParameterMultiPointer< libMesh::Number > &param_pointer) const
	Each subclass will register its copy of an independent. More...

Protected Attributes
unsigned int	_dim
	Physical dimension of problem. More...

libMesh::Real	_C

libMesh::Real	_tau_factor

PrimitiveFlowVariables	_flow_vars

TurbulenceVariables	_turbulence_vars

SpalartAllmarasHelper	_spalart_allmaras_helper

SpalartAllmarasParameters	_sa_params

Detailed Description

Definition at line 44 of file spalart_allmaras_stab_helper.h.

Constructor & Destructor Documentation

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

Definition at line 37 of file spalart_allmaras_stab_helper.C.

     : StabilizationHelper(helper_name),
       _C( input("Stabilization/tau_constant_vel", input("Stabilization/tau_constant", 1 ) ) ),
       _tau_factor( input("Stabilization/tau_factor_vel", input("Stabilization/tau_factor", 0.5 ) ) ),
       _flow_vars(input),
       _turbulence_vars(input),
       _spalart_allmaras_helper(input),
       _sa_params(input)
   {
     return;
   }

GRINS::SpalartAllmarasStabilizationHelper::~SpalartAllmarasStabilizationHelper ( )

Definition at line 50 of file spalart_allmaras_stab_helper.C.

   {
     return;
   }

Member Function Documentation

libMesh::RealGradient GRINS::StabilizationHelper::compute_g	(	libMesh::FEBase *	fe,
		AssemblyContext &	c,
		unsigned int	qp
	)		const

inherited

Todo:: Should we inline this?

Definition at line 47 of file stab_helper.C.

   {
     libMesh::RealGradient g( fe->get_dxidx()[qp] + fe->get_detadx()[qp],
                              fe->get_dxidy()[qp] + fe->get_detady()[qp] );
   
     if( c.get_dim() == 3 )
       {
         g(0) += fe->get_dzetadx()[qp];
         g(1) += fe->get_dzetady()[qp];
         g(2) = fe->get_dxidz()[qp] + fe->get_detadz()[qp] + fe->get_dzetadz()[qp];
       }
   
     return g;
   }

libMesh::RealTensor GRINS::StabilizationHelper::compute_G	(	libMesh::FEBase *	fe,
		AssemblyContext &	c,
		unsigned int	qp
	)		const

inherited

Todo:: Should we inline this?

Definition at line 64 of file stab_helper.C.

   {     
     libMesh::Real dxidx = fe->get_dxidx()[qp];
     libMesh::Real dxidy = fe->get_dxidy()[qp];
   
     libMesh::Real detadx = fe->get_detadx()[qp];
     libMesh::Real detady = fe->get_detady()[qp];
   
     libMesh::RealTensor G( dxidx*dxidx + detadx*detadx,
                            dxidx*dxidy + detadx*detady,
                            0.0,
                            dxidy*dxidx + detady*detadx,
                            dxidy*dxidy + detady*detady,
                            0.0 );
   
     if( c.get_dim() == 3 )
       {
         libMesh::Real dxidz = fe->get_dxidz()[qp];
       
         libMesh::Real detadz = fe->get_detadz()[qp];
       
         libMesh::Real dzetadx = fe->get_dzetadx()[qp];
         libMesh::Real dzetady = fe->get_dzetady()[qp];
         libMesh::Real dzetadz = fe->get_dzetadz()[qp];
       
         G(0,0) += dzetadx*dzetadx;
         G(0,1) += dzetadx*dzetady;
         G(0,2) = dxidx*dxidz + detadx*detadz + dzetadx*dzetadz;
         G(1,0) += dzetady*dzetadx;
         G(1,1) += dzetady*dzetady;
         G(1,2) = dxidy*dxidz + detady*detadz + dzetady*dzetadz;
         G(2,0) = dxidz*dxidx + detadz*detadx + dzetadz*dzetadx;
         G(2,1) = dxidz*dxidy + detadz*detady + dzetadz*dzetady;
         G(2,2) = dxidz*dxidz + detadz*detadz + dzetadz*dzetadz;
       }
   
     return G;
   }

libMesh::Real GRINS::SpalartAllmarasStabilizationHelper::compute_res_spalart_steady	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho,
		const libMesh::Real	mu,
		const libMesh::Real	distance_qp
	)		const

Definition at line 68 of file spalart_allmaras_stab_helper.C.

References _dim, _flow_vars, _sa_params, _spalart_allmaras_helper, _turbulence_vars, GRINS::SpalartAllmarasParameters::destruction_fn(), GRINS::SpalartAllmarasParameters::get_cb1(), GRINS::SpalartAllmarasParameters::get_cb2(), GRINS::SpalartAllmarasParameters::get_cw1(), GRINS::SpalartAllmarasParameters::get_sigma(), GRINS::TurbulenceVariables::nu_var(), GRINS::SpalartAllmarasParameters::source_fn(), GRINS::PrimitiveFlowVariables::u_var(), GRINS::PrimitiveFlowVariables::v_var(), GRINS::SpalartAllmarasHelper::vorticity(), and GRINS::PrimitiveFlowVariables::w_var().

   {
     // The flow velocity
     libMesh::Number u,v;
     u = context.interior_value(this->_flow_vars.u_var(), qp);
     v = context.interior_value(this->_flow_vars.v_var(), qp);
 
     libMesh::NumberVectorValue U(u,v);
     if ( context.get_system().get_mesh().mesh_dimension() == 3 )
       U(2) = context.interior_value(this->_flow_vars.w_var(), qp);
 
     libMesh::RealGradient grad_u = context.fixed_interior_gradient(this->_flow_vars.u_var(), qp);
     libMesh::RealGradient grad_v = context.fixed_interior_gradient(this->_flow_vars.v_var(), qp);
 
     libMesh::Number nu_value = context.interior_value(this->_turbulence_vars.nu_var(), qp);
 
     libMesh::RealGradient grad_nu = context.fixed_interior_gradient(this->_turbulence_vars.nu_var(), qp);
 
     libMesh::RealTensor hess_nu = context.fixed_interior_hessian(this->_turbulence_vars.nu_var(), qp);
 
     // The convection term
     libMesh::Number rhoUdotGradnu = rho*(U*grad_nu);
 
     // The diffusion term
     libMesh::Number inv_sigmadivnuplusnuphysicalGradnu = (1./this->_sa_params.get_sigma())*(grad_nu*grad_nu + ((nu_value + mu)*(hess_nu(0,0) + hess_nu(1,1) + (this->_dim == 3)?hess_nu(2,2):0)) + this->_sa_params.get_cb2()*grad_nu*grad_nu);
 
     // The source term
     libMesh::Real vorticity_value_qp = this->_spalart_allmaras_helper.vorticity(context, qp);
     libMesh::Real S_tilde = this->_sa_params.source_fn(nu_value, mu, distance_qp, vorticity_value_qp);
     libMesh::Real source_term = this->_sa_params.get_cb1()*S_tilde*nu_value;
 
     // The destruction term
     libMesh::Real fw = this->_sa_params.destruction_fn(nu_value, distance_qp, S_tilde);
     libMesh::Real destruction_term =  this->_sa_params.get_cw1()*fw*pow(nu_value/distance_qp, 2.);
 
     return rhoUdotGradnu + source_term + inv_sigmadivnuplusnuphysicalGradnu - destruction_term;
   }

void GRINS::SpalartAllmarasStabilizationHelper::compute_res_spalart_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 108 of file spalart_allmaras_stab_helper.C.

   {
     // To be filled when we start using analytic jacobians with SA
     libmesh_not_implemented();
   }

libMesh::Real GRINS::SpalartAllmarasStabilizationHelper::compute_res_spalart_transient	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho
	)		const

Definition at line 122 of file spalart_allmaras_stab_helper.C.

References _turbulence_vars, and GRINS::TurbulenceVariables::nu_var().

   {
     libMesh::Number nu_dot = context.interior_value(this->_turbulence_vars.nu_var(), qp);
 
     return rho*nu_dot;
   }

void GRINS::SpalartAllmarasStabilizationHelper::compute_res_spalart_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 131 of file spalart_allmaras_stab_helper.C.

   {
     libmesh_not_implemented();
   }

libMesh::Real GRINS::SpalartAllmarasStabilizationHelper::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 180 of file spalart_allmaras_stab_helper.h.

References _C, and _tau_factor.

Referenced by compute_tau_spalart().

   {
     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::SpalartAllmarasStabilizationHelper::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 200 of file spalart_allmaras_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::SpalartAllmarasStabilizationHelper::compute_tau_spalart	(	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 147 of file spalart_allmaras_stab_helper.h.

References compute_tau().

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

void GRINS::SpalartAllmarasStabilizationHelper::compute_tau_spalart_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 161 of file spalart_allmaras_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 );
   }

void GRINS::SpalartAllmarasStabilizationHelper::init ( libMesh::FEMSystem & system )

Definition at line 55 of file spalart_allmaras_stab_helper.C.

References _dim, _flow_vars, _spalart_allmaras_helper, _turbulence_vars, GRINS::TurbulenceVariables::init(), GRINS::PrimitiveFlowVariables::init(), and GRINS::SpalartAllmarasHelper::init_variables().

   {
     this->_flow_vars.init(&system);
     this->_turbulence_vars.init(&system);
 
     // Init the variables belonging to SA helper
     _spalart_allmaras_helper.init_variables(&system);
 
     this->_dim = system.get_mesh().mesh_dimension();
 
     return;
   }

void GRINS::ParameterUser::register_parameter	(	const std::string &	param_name,
		libMesh::ParameterMultiPointer< libMesh::Number > &	param_pointer
	)		const

virtualinherited

Each subclass will register its copy of an independent.

Reimplemented in GRINS::AxisymmetricHeatTransfer< Conductivity >, GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::IncompressibleNavierStokesBase< Viscosity >, GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >, GRINS::HeatConduction< Conductivity >, GRINS::HeatTransferBase< Conductivity >, and GRINS::BoussinesqBuoyancyAdjointStabilization< Viscosity >.

Definition at line 50 of file parameter_user.C.

Referenced by GRINS::BoussinesqBuoyancyAdjointStabilization< Viscosity >::register_parameter(), GRINS::HeatTransferBase< Conductivity >::register_parameter(), GRINS::HeatConduction< Conductivity >::register_parameter(), GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::register_parameter(), GRINS::IncompressibleNavierStokesBase< Viscosity >::register_parameter(), GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::register_parameter(), and GRINS::AxisymmetricHeatTransfer< Conductivity >::register_parameter().

   {
     std::map<std::string, libMesh::Number*>::const_iterator it =
       _my_parameters.find(param_name);
 
     if (it != _my_parameters.end())
       {
         std::cout << _my_name << " uses parameter " << param_name
                   << std::endl;
         param_pointer.push_back(it->second);
       }
   }

void GRINS::ParameterUser::set_parameter	(	libMesh::Number &	param_variable,
		const GetPot &	input,
		const std::string &	param_name,
		libMesh::Number	param_default
	)

virtualinherited

Each subclass can simultaneously read a parameter value from.

Definition at line 35 of file parameter_user.C.

References GRINS::ParameterUser::_my_name, and GRINS::ParameterUser::_my_parameters.

Referenced by GRINS::AveragedFanAdjointStabilization< Viscosity >::AveragedFanAdjointStabilization(), GRINS::AveragedTurbineAdjointStabilization< Viscosity >::AveragedTurbineAdjointStabilization(), GRINS::BoussinesqBuoyancyAdjointStabilization< Viscosity >::BoussinesqBuoyancyAdjointStabilization(), GRINS::BoussinesqBuoyancyBase::BoussinesqBuoyancyBase(), GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::BoussinesqBuoyancySPGSMStabilization(), GRINS::ConstantConductivity::ConstantConductivity(), GRINS::ConstantPrandtlConductivity::ConstantPrandtlConductivity(), GRINS::ConstantSourceFunction::ConstantSourceFunction(), GRINS::ConstantSourceTerm::ConstantSourceTerm(), GRINS::ConstantSpecificHeat::ConstantSpecificHeat(), GRINS::ConstantViscosity::ConstantViscosity(), GRINS::ElasticCable< StressStrainLaw >::ElasticCable(), GRINS::ElasticCableConstantGravity::ElasticCableConstantGravity(), GRINS::ElasticMembrane< StressStrainLaw >::ElasticMembrane(), GRINS::ElasticMembraneConstantPressure::ElasticMembraneConstantPressure(), GRINS::HeatConduction< Conductivity >::HeatConduction(), GRINS::HeatTransferBase< Conductivity >::HeatTransferBase(), GRINS::IncompressibleNavierStokesBase< Viscosity >::IncompressibleNavierStokesBase(), GRINS::AverageNusseltNumber::init(), GRINS::MooneyRivlin::MooneyRivlin(), GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::ReactingLowMachNavierStokesBase(), GRINS::HookesLaw1D::read_input_options(), GRINS::HookesLaw::read_input_options(), GRINS::AxisymmetricBoussinesqBuoyancy::read_input_options(), and GRINS::VelocityDragAdjointStabilization< Viscosity >::VelocityDragAdjointStabilization().

   {
     param_variable = input(param_name, param_default);
 
     libmesh_assert_msg(!_my_parameters.count(param_name),
       "ERROR: " << _my_name << " double-registered parameter " <<
       param_name);
 
     _my_parameters[param_name] = &param_variable;
   }