Physics class for spatially-averaged turbine. More...

#include <averaged_turbine_adjoint_stab.h>

Inheritance diagram for GRINS::AveragedTurbineAdjointStabilization< Viscosity >:

Collaboration diagram for GRINS::AveragedTurbineAdjointStabilization< Viscosity >:

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

	~AveragedTurbineAdjointStabilization ()

virtual void	init_context (AssemblyContext &context)
	Initialize context for added physics variables. More...

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	init_variables (libMesh::FEMSystem *system)
	Initialization of variables. More...

virtual void	set_time_evolving_vars (libMesh::FEMSystem *system)
	Sets turbine_speed and velocity variables to be time-evolving. More...

virtual void	read_input_options (const GetPot &input)
	Read options from GetPot input file. More...

bool	compute_force (const libMesh::Point &point, const libMesh::Real time, const libMesh::NumberVectorValue &U, libMesh::Number s, libMesh::NumberVectorValue &U_B_1, libMesh::NumberVectorValue &F, libMesh::NumberTensorValue dFdU=NULL, libMesh::NumberVectorValue dFds=NULL)

VariableIndex	fan_speed_var () const

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

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	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	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	nonlocal_mass_residual (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Mass matrix part(s) for scalar variables. More...

void	init_bcs (libMesh::FEMSystem *system)

void	init_ics (libMesh::FEMSystem *system, libMesh::CompositeFunction< libMesh::Number > &all_ics)

void	attach_neumann_bound_func (GRINS::NBCContainer &neumann_bcs)

void	attach_dirichlet_bound_func (const GRINS::DBCContainer &dirichlet_bc)

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

BCHandlingBase *	get_bc_handler ()

ICHandlingBase *	get_ic_handler ()

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

Protected Attributes
libMesh::Number	_rho

Viscosity	_mu

IncompressibleNavierStokesStabilizationHelper	_stab_helper

libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	base_velocity_function

libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	local_vertical_function

libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	lift_function

libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	drag_function

libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	torque_function

libMesh::Number	moment_of_inertia

libMesh::Number	initial_speed

libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	chord_function

libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	area_swept_function

libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	aoa_function

VariableIndex	_fan_speed_var

std::string	_fan_speed_var_name

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

PrimitiveFlowFEVariables	_flow_vars

const PhysicsName	_physics_name
	Name of the physics object. Used for reading physics specific inputs. More...

GRINS::BCHandlingBase *	_bc_handler

GRINS::ICHandlingBase *	_ic_handler

std::set< libMesh::subdomain_id_type >	_enabled_subdomains
	Subdomains on which the current Physics class is enabled. More...

bool	_is_axisymmetric

Static Protected Attributes
static bool	_is_steady = false
	Caches whether or not the solver that's being used is steady or not. More...

Private Member Functions
	AveragedTurbineAdjointStabilization ()

Detailed Description

template<class Viscosity>
class GRINS::AveragedTurbineAdjointStabilization< Viscosity >

Physics class for spatially-averaged turbine.

Definition at line 46 of file averaged_turbine_adjoint_stab.h.

Constructor & Destructor Documentation

template<class Mu >

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

Definition at line 41 of file averaged_turbine_adjoint_stab.C.

References GRINS::AveragedTurbineAdjointStabilization< Viscosity >::_rho, GRINS::incompressible_navier_stokes, and GRINS::ParameterUser::set_parameter().

     : AveragedTurbineBase<Mu>(physics_name, input),
       _rho(1.0),
       _mu( input ),
       _stab_helper( physics_name+"StabHelper", input )
   {
     this->set_parameter
       (_rho, input, "Physics/"+incompressible_navier_stokes+"/rho", _rho);
   }

template<class Mu >

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

Definition at line 52 of file averaged_turbine_adjoint_stab.C.

   {
     return;
   }

template<class Viscosity >

GRINS::AveragedTurbineAdjointStabilization< Viscosity >::AveragedTurbineAdjointStabilization ( )

private

Member Function Documentation

void GRINS::Physics::attach_dirichlet_bound_func ( const GRINS::DBCContainer & dirichlet_bc )

inherited

Definition at line 150 of file physics.C.

References GRINS::Physics::_bc_handler, and GRINS::BCHandlingBase::attach_dirichlet_bound_func().

   {
     _bc_handler->attach_dirichlet_bound_func( dirichlet_bc );
     return;
   }

void GRINS::Physics::attach_neumann_bound_func ( GRINS::NBCContainer & neumann_bcs )

inherited

Definition at line 144 of file physics.C.

References GRINS::Physics::_bc_handler, and GRINS::BCHandlingBase::attach_neumann_bound_func().

   {
     _bc_handler->attach_neumann_bound_func( neumann_bcs );
     return;
   }

void GRINS::Physics::auxiliary_init ( MultiphysicsSystem & system )

virtualinherited

Any auxillary initialization a Physics class may need.

This is called after all variables are added, so this method can safely query the MultiphysicsSystem about variable information.

Definition at line 113 of file physics.C.

   {
     return;
   }

void GRINS::Physics::compute_element_constraint_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 185 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::element_constraint().

   {
     return;
   }

void GRINS::Physics::compute_element_time_derivative_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Reimplemented in GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 167 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::element_time_derivative().

   {
     return;
   }

template<class Mu >

bool GRINS::AveragedTurbineBase< Mu >::compute_force	(	const libMesh::Point &	point,
		const libMesh::Real	time,
		const libMesh::NumberVectorValue &	U,
		libMesh::Number	s,
		libMesh::NumberVectorValue &	U_B_1,
		libMesh::NumberVectorValue &	F,
		libMesh::NumberTensorValue *	dFdU = `NULL`,
		libMesh::NumberVectorValue *	dFds = `NULL`
	)

inherited

Definition at line 189 of file averaged_turbine_base.C.

   {
     // Find base velocity of moving fan at this point
     libmesh_assert(base_velocity_function.get());
 
     libMesh::DenseVector<libMesh::Number> output_vec(3);
 
     (*base_velocity_function)(point, time,
                               output_vec);
 
     U_B_1(0) = output_vec(0);
     U_B_1(1) = output_vec(1);
     U_B_1(2) = output_vec(2);
 
     const libMesh::NumberVectorValue U_B = U_B_1 * s;
 
     const libMesh::Number U_B_size = U_B.size();
 
     // If there's no base velocity there's no fan
     if (!U_B_size)
       return false;
 
     // Normal in fan velocity direction
     const libMesh::NumberVectorValue N_B =
       libMesh::NumberVectorValue(U_B/U_B_size);
 
     (*local_vertical_function)(point, time,
                                output_vec);
 
     // Normal in fan vertical direction
     const libMesh::NumberVectorValue N_V(output_vec(0),
                                          output_vec(1),
                                          output_vec(2));
 
     // Normal in radial direction (or opposite radial direction,
     // for fans turning clockwise!)
     const libMesh::NumberVectorValue N_R = N_B.cross(N_V);
 
     // Fan-wing-plane component of local relative velocity
     const libMesh::NumberVectorValue U_P = U - (U*N_R)*N_R - U_B;
 
     const libMesh::Number U_P_size = U_P.size();
 
     // If there's no flow in the fan's frame of reference, there's no
     // lift or drag.  FIXME - should we account for drag in the
     // out-of-plane direction?
     if (!U_P_size)
       return false;
 
     // Direction opposing drag
     const libMesh::NumberVectorValue N_drag =
       libMesh::NumberVectorValue(-U_P/U_P_size);
 
     // Direction opposing lift
     const libMesh::NumberVectorValue N_lift = N_drag.cross(N_R);
 
     // "Forward" velocity
     const libMesh::Number u_fwd = -(U_P * N_B);
 
     // "Upward" velocity
     const libMesh::Number u_up = U_P * N_V;
 
     // If there's no forward or upward velocity we should have already
     // returned false
     libmesh_assert (u_up || u_fwd);
 
     // Angle WRT fan velocity direction
     const libMesh::Number part_angle = std::atan2(u_up, u_fwd);
 
     // Angle WRT fan chord
     const libMesh::Number angle = part_angle +
       (*aoa_function)(point, time);
 
     const libMesh::Number C_lift  = (*lift_function)(point, angle);
     const libMesh::Number C_drag  = (*drag_function)(point, angle);
 
     const libMesh::Number chord = (*chord_function)(point, time);
     const libMesh::Number area  = (*area_swept_function)(point, time);
 
     const libMesh::Number v_sq = U_P*U_P;
 
     const libMesh::Number LDfactor = 0.5 * this->_rho * v_sq * chord / area;
     const libMesh::Number lift = C_lift * LDfactor;
     const libMesh::Number drag = C_drag * LDfactor;
 
     // Force 
     F = lift * N_lift + drag * N_drag;
 
     if (dFdU)
       {
         const libMesh::NumberVectorValue LDderivfactor = 
           (N_lift*C_lift+N_drag*C_drag) *
           this->_rho * chord / area;
 
         const libMesh::Number sfactor = -(U_P*U_B_1);
 
         (*dFds) = LDderivfactor * sfactor;
 
         for (unsigned int i=0; i != 3; ++i)
           for (unsigned int j=0; j != 3; ++j)
             (*dFdU)(i,j) = LDderivfactor(i) * U_P(j);
       }
 
     return true;
   }

void GRINS::Physics::compute_mass_residual_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 203 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::mass_residual().

   {
     return;
   }

void GRINS::Physics::compute_nonlocal_constraint_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 197 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_constraint().

   {
     return;
   }

void GRINS::Physics::compute_nonlocal_mass_residual_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 209 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_mass_residual().

   {
     return;
   }

void GRINS::Physics::compute_nonlocal_time_derivative_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 179 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_time_derivative().

   {
     return;
   }

void GRINS::Physics::compute_postprocessed_quantity	(	unsigned int	quantity_index,
		const AssemblyContext &	context,
		const libMesh::Point &	point,
		libMesh::Real &	value
	)

virtualinherited

Reimplemented in GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >, GRINS::HeatTransfer< Conductivity >, GRINS::ParsedVelocitySource< Viscosity >, GRINS::VelocityPenalty< Viscosity >, GRINS::ElasticMembrane< StressStrainLaw >, and GRINS::ElasticCable< StressStrainLaw >.

Definition at line 271 of file physics.C.

   {
     return;
   }

void GRINS::Physics::compute_side_constraint_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 191 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::side_constraint().

   {
     return;
   }

void GRINS::Physics::compute_side_time_derivative_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Reimplemented in GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 173 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::side_time_derivative().

   {
     return;
   }

template<class Mu >

void GRINS::AveragedTurbineAdjointStabilization< 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 257 of file averaged_turbine_adjoint_stab.C.

   {
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->BeginTimer("AveragedTurbineAdjointStabilization::element_constraint");
 #endif
 
     // The number of local degrees of freedom in each variable.
     const unsigned int n_p_dofs = context.get_dof_indices(this->_flow_vars.p_var()).size();
     const unsigned int n_u_dofs = context.get_dof_indices(this->_flow_vars.u_var()).size();
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(this->_flow_vars.u_var())->get_JxW();
 
     const std::vector<libMesh::Point>& u_qpoint = 
       context.get_element_fe(this->_flow_vars.u_var())->get_xyz();
 
     const std::vector<std::vector<libMesh::Real> >& u_phi =
       context.get_element_fe(this->_flow_vars.u_var())->get_phi();
 
     const std::vector<std::vector<libMesh::RealGradient> >& p_dphi =
       context.get_element_fe(this->_flow_vars.p_var())->get_dphi();
 
     libMesh::DenseSubVector<libMesh::Number> &Fp = context.get_elem_residual(this->_flow_vars.p_var()); // R_{p}
 
     libMesh::DenseSubMatrix<libMesh::Number> &Kpu = 
       context.get_elem_jacobian(this->_flow_vars.p_var(), this->_flow_vars.u_var()); // J_{pu}
     libMesh::DenseSubMatrix<libMesh::Number> &Kpv = 
       context.get_elem_jacobian(this->_flow_vars.p_var(), this->_flow_vars.v_var()); // J_{pv}
     libMesh::DenseSubMatrix<libMesh::Number> &Kps = 
       context.get_elem_jacobian(this->_flow_vars.p_var(), this->fan_speed_var()); // J_{ps}
 
     libMesh::DenseSubMatrix<libMesh::Number> *Kpw = NULL;
  
     if(this->_dim == 3)
       {
         Kpw = &context.get_elem_jacobian
           (this->_flow_vars.p_var(), this->_flow_vars.w_var()); // 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_var());
 
     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_var(), qp ),
                                  context.interior_value( this->_flow_vars.v_var(), qp ) );
 
         if( this->_dim == 3 )
           {
             U(2) = context.interior_value( this->_flow_vars.w_var(), qp );
           }
 
         libMesh::Number s = context.interior_value(this->fan_speed_var(), 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 U_B_1;
         libMesh::NumberVectorValue F;
         libMesh::NumberTensorValue dFdU;
         libMesh::NumberTensorValue* dFdU_ptr =
           compute_jacobian ? &dFdU : NULL;
         libMesh::NumberVectorValue dFds;
         libMesh::NumberVectorValue* dFds_ptr =
           compute_jacobian ? &dFds : NULL;
         if (!this->compute_force(u_qpoint[qp], context.time, U, s,
                                  U_B_1, F, dFdU_ptr, dFds_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)
               {
                 Kps(i,0) += -tau_M*(dFds*p_dphi[i][qp])*JxW[qp];
 
                 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];
                     Kpv(i,j) += -d_tau_M_dU(1)*u_phi[j][qp]*(F*p_dphi[i][qp])*JxW[qp];
                     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];
                         Kpv(i,j) += -tau_M*dFdU(d,1)*u_phi[j][qp]*p_dphi[i][qp](d)*JxW[qp];
                       }
                   }
                 if( this->_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];
                       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];
                         }
                     }
               }
           }
       } // End quadrature loop
 
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->EndTimer("AveragedTurbineAdjointStabilization::element_constraint");
 #endif
 
     return;
   }

template<class Mu >

void GRINS::AveragedTurbineAdjointStabilization< 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 72 of file averaged_turbine_adjoint_stab.C.

   {
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->BeginTimer("AveragedTurbineAdjointStabilization::element_time_derivative");
 #endif
 
     libMesh::FEBase* fe = context.get_element_fe(this->_flow_vars.u_var());
 
     // Element Jacobian * quadrature weights for interior integration
     const std::vector<libMesh::Real> &JxW = fe->get_JxW();
 
     // The shape functions at interior quadrature points.
     const std::vector<std::vector<libMesh::Real> >& u_phi = fe->get_phi();
 
     const std::vector<std::vector<libMesh::RealGradient> >& u_gradphi =
       context.get_element_fe(this->_flow_vars.u_var())->get_dphi();
 
     const std::vector<std::vector<libMesh::RealTensor> >& u_hessphi =
       context.get_element_fe(this->_flow_vars.u_var())->get_d2phi();
 
     const std::vector<libMesh::Point>& u_qpoint = fe->get_xyz();
 
     // The number of local degrees of freedom in each variable
     const unsigned int n_u_dofs = context.get_dof_indices(this->_flow_vars.u_var()).size();
 
     // The subvectors and submatrices we need to fill:
     libMesh::DenseSubMatrix<libMesh::Number> &Kuu = context.get_elem_jacobian(this->_flow_vars.u_var(), this->_flow_vars.u_var()); // R_{u},{u}
     libMesh::DenseSubMatrix<libMesh::Number> &Kuv = context.get_elem_jacobian(this->_flow_vars.u_var(), this->_flow_vars.v_var()); // R_{u},{v}
     libMesh::DenseSubMatrix<libMesh::Number> &Kvu = context.get_elem_jacobian(this->_flow_vars.v_var(), this->_flow_vars.u_var()); // R_{v},{u}
     libMesh::DenseSubMatrix<libMesh::Number> &Kvv = context.get_elem_jacobian(this->_flow_vars.v_var(), this->_flow_vars.v_var()); // R_{v},{v}
 
     libMesh::DenseSubMatrix<libMesh::Number> &Kus =
             context.get_elem_jacobian(this->_flow_vars.u_var(),
                                       this->fan_speed_var()); // R_{u},{s}
     libMesh::DenseSubMatrix<libMesh::Number> &Kvs =
             context.get_elem_jacobian(this->_flow_vars.v_var(),
                                       this->fan_speed_var()); // R_{v},{s}
 
     libMesh::DenseSubMatrix<libMesh::Number>* Kwu = NULL;
     libMesh::DenseSubMatrix<libMesh::Number>* Kwv = NULL;
     libMesh::DenseSubMatrix<libMesh::Number>* Kww = NULL;
     libMesh::DenseSubMatrix<libMesh::Number>* Kuw = NULL;
     libMesh::DenseSubMatrix<libMesh::Number>* Kvw = NULL;
 
     libMesh::DenseSubMatrix<libMesh::Number>* Kws = NULL;
 
     libMesh::DenseSubVector<libMesh::Number> &Fu = context.get_elem_residual(this->_flow_vars.u_var()); // R_{u}
     libMesh::DenseSubVector<libMesh::Number> &Fv = context.get_elem_residual(this->_flow_vars.v_var()); // R_{v}
     libMesh::DenseSubVector<libMesh::Number>* Fw = NULL;
 
     if( this->_dim == 3 )
       {
         Kuw = &context.get_elem_jacobian(this->_flow_vars.u_var(), this->_flow_vars.w_var()); // R_{u},{w}
         Kvw = &context.get_elem_jacobian(this->_flow_vars.v_var(), this->_flow_vars.w_var()); // R_{v},{w}
 
         Kwu = &context.get_elem_jacobian(this->_flow_vars.w_var(), this->_flow_vars.u_var()); // R_{w},{u}
         Kwv = &context.get_elem_jacobian(this->_flow_vars.w_var(), this->_flow_vars.v_var()); // R_{w},{v}
         Kww = &context.get_elem_jacobian(this->_flow_vars.w_var(), this->_flow_vars.w_var()); // R_{w},{w}
 
         Kws = &context.get_elem_jacobian(this->_flow_vars.w_var(), this->fan_speed_var()); // R_{w},{s}
 
         Fw  = &context.get_elem_residual(this->_flow_vars.w_var()); // R_{w}
       }
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     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_var(), qp ),
                                  context.interior_value( this->_flow_vars.v_var(), qp ) );
 
         if( this->_dim == 3 )
           {
             U(2) = context.interior_value( this->_flow_vars.w_var(), qp );
           }
 
         libMesh::Number s = context.interior_value(this->fan_speed_var(), 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 U_B_1;
         libMesh::NumberVectorValue F;
         libMesh::NumberTensorValue dFdU;
         libMesh::NumberTensorValue* dFdU_ptr =
           compute_jacobian ? &dFdU : NULL;
         libMesh::NumberVectorValue dFds;
         libMesh::NumberVectorValue* dFds_ptr =
           compute_jacobian ? &dFds : NULL;
         if (!this->compute_force(u_qpoint[qp], context.time, U, s,
                                  U_B_1, F, dFdU_ptr, dFds_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->_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];
                     Kuu(i,j) += d_tau_M_dU(0)*u_phi[j][qp]*F(0)*test_func*JxW[qp];
                     Kuu(i,j) += tau_M*dFdU(0,0)*u_phi[j][qp]*test_func*JxW[qp];
                     Kuv(i,j) += tau_M*F(0)*d_test_func_dU(1)*u_phi[j][qp]*JxW[qp];
                     Kuv(i,j) += d_tau_M_dU(1)*u_phi[j][qp]*F(0)*test_func*JxW[qp];
                     Kuv(i,j) += tau_M*dFdU(0,1)*u_phi[j][qp]*test_func*JxW[qp];
                     Kvu(i,j) += tau_M*F(1)*d_test_func_dU(0)*u_phi[j][qp]*JxW[qp];
                     Kvu(i,j) += d_tau_M_dU(0)*u_phi[j][qp]*F(1)*test_func*JxW[qp];
                     Kvu(i,j) += tau_M*dFdU(1,0)*u_phi[j][qp]*test_func*JxW[qp];
                     Kvv(i,j) += tau_M*F(1)*d_test_func_dU(1)*u_phi[j][qp]*JxW[qp];
                     Kvv(i,j) += d_tau_M_dU(1)*u_phi[j][qp]*F(1)*test_func*JxW[qp];
                     Kvv(i,j) += tau_M*dFdU(1,1)*u_phi[j][qp]*test_func*JxW[qp];
 
                     Kus(i,0)   += tau_M*dFds(0)*test_func*JxW[qp];
                     Kvs(i,0)   += tau_M*dFds(1)*test_func*JxW[qp];
                   }
 
                 if (this->_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];
                         (*Kuw)(i,j) += d_tau_M_dU(2)*u_phi[j][qp]*F(0)*test_func*JxW[qp];
                         (*Kuw)(i,j) += tau_M*dFdU(0,2)*u_phi[j][qp]*test_func*JxW[qp];
                         (*Kvw)(i,j) += tau_M*F(1)*d_test_func_dU(2)*u_phi[j][qp]*JxW[qp];
                         (*Kvw)(i,j) += d_tau_M_dU(2)*u_phi[j][qp]*F(1)*test_func*JxW[qp];
                         (*Kvw)(i,j) += tau_M*dFdU(1,2)*u_phi[j][qp]*test_func*JxW[qp];
                         (*Kwu)(i,j) += tau_M*F(2)*d_test_func_dU(0)*u_phi[j][qp]*JxW[qp];
                         (*Kwu)(i,j) += d_tau_M_dU(0)*u_phi[j][qp]*F(2)*test_func*JxW[qp];
                         (*Kwu)(i,j) += tau_M*dFdU(2,0)*u_phi[j][qp]*test_func*JxW[qp];
                         (*Kwv)(i,j) += tau_M*F(2)*d_test_func_dU(1)*u_phi[j][qp]*JxW[qp];
                         (*Kwv)(i,j) += d_tau_M_dU(1)*u_phi[j][qp]*F(2)*test_func*JxW[qp];
                         (*Kwv)(i,j) += tau_M*dFdU(2,1)*u_phi[j][qp]*test_func*JxW[qp];
                         (*Kww)(i,j) += tau_M*F(2)*d_test_func_dU(2)*u_phi[j][qp]*JxW[qp];
                         (*Kww)(i,j) += d_tau_M_dU(2)*u_phi[j][qp]*F(2)*test_func*JxW[qp];
                         (*Kww)(i,j) += tau_M*dFdU(2,2)*u_phi[j][qp]*test_func*JxW[qp];
 
                         (*Kws)(i,0) += tau_M*dFds(2)*test_func*JxW[qp];
                       }
                   }
 
               } // End compute_jacobian check
 
           } // End i dof loop
       }
 
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->EndTimer("AveragedTurbineAdjointStabilization::element_time_derivative");
 #endif
 
     return;
   }

bool GRINS::Physics::enabled_on_elem ( const libMesh::Elem * elem )

virtualinherited

Find if current physics is active on supplied element.

Definition at line 83 of file physics.C.

References GRINS::Physics::_enabled_subdomains.

   {
     // Check if enabled_subdomains flag has been set and if we're
     // looking at a real element (rather than a nonlocal evaluation)
     if( !elem || _enabled_subdomains.empty() ) 
       return true;
   
     // Check if current physics is enabled on elem
     if( _enabled_subdomains.find( elem->subdomain_id() ) == _enabled_subdomains.end() )
       return false;
 
     return true;
   }

template<class Viscosity >

VariableIndex GRINS::AveragedTurbineBase< Viscosity >::fan_speed_var ( ) const

inlineinherited

Definition at line 75 of file averaged_turbine_base.h.

References GRINS::AveragedTurbineBase< Viscosity >::_fan_speed_var.

75 { return _fan_speed_var; }

GRINS::AveragedTurbineBase::_fan_speed_var

VariableIndex _fan_speed_var

Definition: averaged_turbine_base.h:138

BCHandlingBase * GRINS::Physics::get_bc_handler ( )

inlineinherited

Definition at line 282 of file physics.h.

References GRINS::Physics::_bc_handler.

   {
     return _bc_handler;
   }

ICHandlingBase * GRINS::Physics::get_ic_handler ( )

inlineinherited

Definition at line 288 of file physics.h.

References GRINS::Physics::_ic_handler.

   {
     return _ic_handler;
   }

void GRINS::Physics::init_bcs ( libMesh::FEMSystem * system )

inherited

Definition at line 118 of file physics.C.

References GRINS::Physics::_bc_handler, GRINS::BCHandlingBase::init_bc_data(), GRINS::BCHandlingBase::init_dirichlet_bc_func_objs(), GRINS::BCHandlingBase::init_dirichlet_bcs(), and GRINS::BCHandlingBase::init_periodic_bcs().

   {
     // Only need to init BC's if the physics actually created a handler
     if( _bc_handler )
       {
         _bc_handler->init_bc_data( *system );
         _bc_handler->init_dirichlet_bcs( system );
         _bc_handler->init_dirichlet_bc_func_objs( system );
         _bc_handler->init_periodic_bcs( system );
       }
 
     return;
   }

template<class Mu >

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

virtual

Initialize context for added physics variables.

Reimplemented from GRINS::IncompressibleNavierStokesBase< Viscosity >.

Definition at line 58 of file averaged_turbine_adjoint_stab.C.

   {
     context.get_element_fe(this->_flow_vars.p_var())->get_dphi();
 
     context.get_element_fe(this->_flow_vars.u_var())->get_xyz();
     context.get_element_fe(this->_flow_vars.u_var())->get_phi();
     context.get_element_fe(this->_flow_vars.u_var())->get_dphi();
     context.get_element_fe(this->_flow_vars.u_var())->get_d2phi();
 
     return;
   }

void GRINS::Physics::init_ics	(	libMesh::FEMSystem *	system,
		libMesh::CompositeFunction< libMesh::Number > &	all_ics
	)

inherited

Definition at line 133 of file physics.C.

References GRINS::Physics::_ic_handler, and GRINS::ICHandlingBase::init_ic_data().

   {
     if( _ic_handler )
       {
         _ic_handler->init_ic_data( *system, all_ics );
       }
 
     return;
   }

template<class Mu >

void GRINS::AveragedTurbineBase< Mu >::init_variables ( libMesh::FEMSystem * system )

virtualinherited

Initialization of variables.

Add turbine_speed variable to system; call base function to initialize Navier-Stokes variables.

Reimplemented from GRINS::IncompressibleNavierStokesBase< Viscosity >.

Definition at line 57 of file averaged_turbine_base.C.

References GRINS::IncompressibleNavierStokesBase< Viscosity >::init_variables().

   {
     this->_fan_speed_var = system->add_variable(_fan_speed_var_name,
                                                 libMesh::FIRST,
                                                 libMesh::SCALAR);
 
     IncompressibleNavierStokesBase<Mu>::init_variables(system);
   }

bool GRINS::Physics::is_steady ( ) const

inherited

Returns whether or not this physics is being solved with a steady solver.

Definition at line 103 of file physics.C.

References GRINS::Physics::_is_steady.

Referenced by GRINS::Physics::set_is_steady().

   {
     return _is_steady;
   }

void GRINS::Physics::mass_residual	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

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

Reimplemented in GRINS::AxisymmetricHeatTransfer< Conductivity >, GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::SpalartAllmaras< Viscosity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::HeatTransfer< Conductivity >, GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >, GRINS::Stokes< Viscosity >, GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >, GRINS::ElasticMembrane< StressStrainLaw >, GRINS::ElasticCable< StressStrainLaw >, GRINS::HeatConduction< Conductivity >, GRINS::IncompressibleNavierStokesAdjointStabilization< Viscosity >, GRINS::IncompressibleNavierStokesSPGSMStabilization< Viscosity >, GRINS::SpalartAllmarasSPGSMStabilization< Viscosity >, GRINS::HeatTransferAdjointStabilization< Conductivity >, GRINS::HeatTransferSPGSMStabilization< Conductivity >, GRINS::LowMachNavierStokesBraackStabilization< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::LowMachNavierStokesVMSStabilization< Viscosity, SpecificHeat, ThermalConductivity >, and GRINS::LowMachNavierStokesSPGSMStabilization< Viscosity, SpecificHeat, ThermalConductivity >.

Definition at line 257 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::mass_residual().

   {
     return;
   }

void GRINS::Physics::nonlocal_constraint	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Constraint part(s) of physics for scalar variables.

Reimplemented in GRINS::ScalarODE.

Definition at line 250 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_constraint().

   {
     return;
   }   

void GRINS::Physics::nonlocal_mass_residual	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Mass matrix part(s) for scalar variables.

Reimplemented in GRINS::ScalarODE, and GRINS::AveragedTurbine< Viscosity >.

Definition at line 264 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_mass_residual().

   {
     return;
   }

void GRINS::Physics::nonlocal_time_derivative	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Time dependent part(s) of physics for scalar variables.

Reimplemented in GRINS::AveragedTurbine< Viscosity >, and GRINS::ScalarODE.

Definition at line 229 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_time_derivative().

   {
     return;
   }

template<class Mu >

void GRINS::AveragedTurbineBase< Mu >::read_input_options ( const GetPot & input )

virtualinherited

Read options from GetPot input file.

Reimplemented from GRINS::Physics.

Definition at line 76 of file averaged_turbine_base.C.

References GRINS::averaged_turbine, and GRINS::fan_speed_var_name_default.

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

   {
     std::string base_function =
       input("Physics/"+averaged_turbine+"/base_velocity",
         std::string("0"));
 
     if (base_function == "0")
       libmesh_error_msg("Error! Zero AveragedTurbine specified!" <<
                         std::endl);
 
     if (base_function == "0")
       this->base_velocity_function.reset
         (new libMesh::ZeroFunction<libMesh::Number>());
     else
       this->base_velocity_function.reset
         (new libMesh::ParsedFunction<libMesh::Number>(base_function));
 
     std::string vertical_function =
       input("Physics/"+averaged_turbine+"/local_vertical",
         std::string("0"));
 
     if (vertical_function == "0")
       libmesh_error_msg("Warning! Zero LocalVertical specified!" <<
                         std::endl);
 
     this->local_vertical_function.reset
       (new libMesh::ParsedFunction<libMesh::Number>(vertical_function));
 
     std::string lift_function_string =
       input("Physics/"+averaged_turbine+"/lift",
         std::string("0"));
 
     if (lift_function_string == "0")
       std::cout << "Warning! Zero lift function specified!" << std::endl;
 
     this->lift_function.reset
       (new libMesh::ParsedFunction<libMesh::Number>(lift_function_string));
 
     std::string drag_function_string =
       input("Physics/"+averaged_turbine+"/drag",
         std::string("0"));
 
     if (drag_function_string == "0")
       std::cout << "Warning! Zero drag function specified!" << std::endl;
 
     this->drag_function.reset
       (new libMesh::ParsedFunction<libMesh::Number>(drag_function_string));
 
     std::string chord_function_string =
       input("Physics/"+averaged_turbine+"/chord_length",
         std::string("0"));
 
     if (chord_function_string == "0")
       libmesh_error_msg("Warning! Zero chord function specified!" <<
                         std::endl);
 
     this->chord_function.reset
       (new libMesh::ParsedFunction<libMesh::Number>(chord_function_string));
 
     std::string area_function_string =
       input("Physics/"+averaged_turbine+"/area_swept",
         std::string("0"));
 
     if (area_function_string == "0")
       libmesh_error_msg("Warning! Zero area_swept_function specified!" <<
                         std::endl);
 
     this->area_swept_function.reset
       (new libMesh::ParsedFunction<libMesh::Number>(area_function_string));
 
     std::string aoa_function_string =
       input("Physics/"+averaged_turbine+"/angle_of_attack",
         std::string("00000"));
 
     if (aoa_function_string == "00000")
       libmesh_error_msg("Warning! No angle-of-attack specified!" <<
                         std::endl);
 
     this->aoa_function.reset
       (new libMesh::ParsedFunction<libMesh::Number>(aoa_function_string));
 
     std::string torque_function_string =
       input("Physics/"+averaged_turbine+"/torque",
         std::string("0"));
 
     if (torque_function_string == "0")
       std::cout << "Warning! Zero torque function specified!" << std::endl;
 
     this->torque_function.reset
       (new libMesh::ParsedFunction<libMesh::Number>(torque_function_string));
 
     this->set_parameter
       (this->moment_of_inertia, input,
        "Physics/"+averaged_turbine+"/moment_of_inertia",
        libMesh::Number(0));
 
     if (!moment_of_inertia)
       libmesh_error_msg(
         "Error! Zero AveragedTurbine moment of inertia specified!" <<
         std::endl);
 
     this->set_parameter
       (this->initial_speed, input,
        "Physics/"+averaged_turbine+"/initial_speed",
        libMesh::Number(0));
 
     this->_fan_speed_var_name = input("Physics/VariableNames/fan_speed",
                                       fan_speed_var_name_default);
 
   }

template<class Mu >

void GRINS::IncompressibleNavierStokesBase< Mu >::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 from GRINS::ParameterUser.

Definition at line 114 of file inc_navier_stokes_base.C.

References GRINS::ParameterUser::register_parameter().

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

void GRINS::Physics::register_postprocessing_vars	(	const GetPot &	input,
		PostProcessedQuantities< libMesh::Real > &	postprocessing
	)

virtualinherited

Register name of postprocessed quantity with PostProcessedQuantities.

Each Physics class will need to cache an unsigned int corresponding to each postprocessed quantity. This will be used in computing the values and putting them in the CachedVariables object.

Reimplemented in GRINS::ParsedVelocitySource< Viscosity >, GRINS::VelocityPenalty< Viscosity >, GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::HeatTransfer< Conductivity >, GRINS::ElasticCable< StressStrainLaw >, GRINS::ElasticMembrane< StressStrainLaw >, and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 161 of file physics.C.

   {
     return;
   }

void GRINS::Physics::set_is_steady ( bool is_steady )

inherited

Sets whether this physics is to be solved with a steady solver or not.

Since the member variable is static, only needs to be called on a single physics.

Definition at line 97 of file physics.C.

References GRINS::Physics::_is_steady, and GRINS::Physics::is_steady().

   {
     _is_steady = is_steady;
     return;
   }

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

template<class Mu >

void GRINS::AveragedTurbineBase< Mu >::set_time_evolving_vars ( libMesh::FEMSystem * system )

virtualinherited

Sets turbine_speed and velocity variables to be time-evolving.

Reimplemented from GRINS::IncompressibleNavierStokesBase< Viscosity >.

Definition at line 67 of file averaged_turbine_base.C.

References GRINS::IncompressibleNavierStokesBase< Viscosity >::set_time_evolving_vars().

   {
     system->time_evolving(this->fan_speed_var());
 
     IncompressibleNavierStokesBase<Mu>::set_time_evolving_vars(system);
   }

void GRINS::Physics::side_constraint	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Constraint part(s) of physics for boundaries of elements on the domain boundary.

Reimplemented in GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 243 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::side_constraint().

   {
     return;
   }   

void GRINS::Physics::side_time_derivative	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Time dependent part(s) of physics for boundaries of elements on the domain boundary.

Reimplemented in GRINS::AxisymmetricHeatTransfer< Conductivity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::HeatTransfer< Conductivity >, GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >, GRINS::ElasticCable< StressStrainLaw >, and GRINS::ElasticMembrane< StressStrainLaw >.

Definition at line 222 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::side_time_derivative().

   {
     return;
   }

Member Data Documentation

GRINS::BCHandlingBase* GRINS::Physics::_bc_handler

protectedinherited

Definition at line 256 of file physics.h.

Referenced by GRINS::Physics::attach_dirichlet_bound_func(), GRINS::Physics::attach_neumann_bound_func(), GRINS::AxisymmetricHeatTransfer< Conductivity >::AxisymmetricHeatTransfer(), GRINS::ElasticCable< StressStrainLaw >::ElasticCable(), GRINS::ElasticMembrane< StressStrainLaw >::ElasticMembrane(), GRINS::Physics::get_bc_handler(), GRINS::HeatConduction< Conductivity >::HeatConduction(), GRINS::HeatTransfer< Conductivity >::HeatTransfer(), GRINS::IncompressibleNavierStokes< Viscosity >::IncompressibleNavierStokes(), GRINS::Physics::init_bcs(), GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >::LowMachNavierStokes(), GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes(), GRINS::SpalartAllmaras< Viscosity >::SpalartAllmaras(), GRINS::Stokes< Viscosity >::Stokes(), and GRINS::Physics::~Physics().

template<class Viscosity >

unsigned int GRINS::IncompressibleNavierStokesBase< Viscosity >::_dim

protectedinherited

Physical dimension of problem.

Todo:: Do we really need to cache this?

Definition at line 79 of file inc_navier_stokes_base.h.

std::set<libMesh::subdomain_id_type> GRINS::Physics::_enabled_subdomains

protectedinherited

Subdomains on which the current Physics class is enabled.

Definition at line 261 of file physics.h.

Referenced by GRINS::Physics::enabled_on_elem(), and GRINS::Physics::read_input_options().

template<class Viscosity >

VariableIndex GRINS::AveragedTurbineBase< Viscosity >::_fan_speed_var

protectedinherited

Definition at line 138 of file averaged_turbine_base.h.

Referenced by GRINS::AveragedTurbineBase< Viscosity >::fan_speed_var().

template<class Viscosity >

std::string GRINS::AveragedTurbineBase< Viscosity >::_fan_speed_var_name

protectedinherited

Definition at line 140 of file averaged_turbine_base.h.

template<class Viscosity >

PrimitiveFlowFEVariables GRINS::IncompressibleNavierStokesBase< Viscosity >::_flow_vars

protectedinherited

Definition at line 81 of file inc_navier_stokes_base.h.

GRINS::ICHandlingBase* GRINS::Physics::_ic_handler

protectedinherited

Definition at line 258 of file physics.h.

Referenced by GRINS::AveragedTurbine< Viscosity >::AveragedTurbine(), GRINS::AxisymmetricHeatTransfer< Conductivity >::AxisymmetricHeatTransfer(), GRINS::ElasticCable< StressStrainLaw >::ElasticCable(), GRINS::ElasticMembrane< StressStrainLaw >::ElasticMembrane(), GRINS::Physics::get_ic_handler(), GRINS::HeatConduction< Conductivity >::HeatConduction(), GRINS::HeatTransfer< Conductivity >::HeatTransfer(), GRINS::IncompressibleNavierStokes< Viscosity >::IncompressibleNavierStokes(), GRINS::Physics::init_ics(), GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >::LowMachNavierStokes(), GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes(), GRINS::ScalarODE::ScalarODE(), GRINS::SpalartAllmaras< Viscosity >::SpalartAllmaras(), GRINS::Stokes< Viscosity >::Stokes(), and GRINS::Physics::~Physics().

bool GRINS::Physics::_is_axisymmetric

protectedinherited

Definition at line 268 of file physics.h.

Referenced by GRINS::HeatTransfer< Conductivity >::HeatTransfer(), GRINS::IncompressibleNavierStokes< Viscosity >::IncompressibleNavierStokes(), GRINS::Physics::Physics(), and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes().

bool GRINS::Physics::_is_steady = false

staticprotectedinherited

Caches whether or not the solver that's being used is steady or not.

This is need, for example, in flow stabilization as the tau terms change depending on whether the solver is steady or unsteady.

Definition at line 266 of file physics.h.

Referenced by GRINS::Physics::is_steady(), and GRINS::Physics::set_is_steady().

template<class Viscosity >

Viscosity GRINS::AveragedTurbineAdjointStabilization< Viscosity >::_mu

protected

Definition at line 71 of file averaged_turbine_adjoint_stab.h.

const PhysicsName GRINS::Physics::_physics_name

protectedinherited

Name of the physics object. Used for reading physics specific inputs.

We use a reference because the physics names are const global objects in GRINS namespace

No, we use a copy, because otherwise as soon as the memory in std::set<std::string> requested_physics gets overwritten we get in trouble.

Definition at line 254 of file physics.h.

Referenced by GRINS::SourceTermBase::parse_var_info(), and GRINS::Physics::read_input_options().

template<class Viscosity >

libMesh::Number GRINS::AveragedTurbineAdjointStabilization< Viscosity >::_rho

protected

Definition at line 69 of file averaged_turbine_adjoint_stab.h.

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

template<class Viscosity >

IncompressibleNavierStokesStabilizationHelper GRINS::AveragedTurbineAdjointStabilization< Viscosity >::_stab_helper

protected

Definition at line 73 of file averaged_turbine_adjoint_stab.h.

template<class Viscosity >

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::AveragedTurbineBase< Viscosity >::aoa_function

protectedinherited

Definition at line 136 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::AveragedTurbineBase< Viscosity >::area_swept_function

protectedinherited

Definition at line 131 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::AveragedTurbineBase< Viscosity >::base_velocity_function

protectedinherited

Definition at line 86 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::AveragedTurbineBase< Viscosity >::chord_function

protectedinherited

Definition at line 126 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::AveragedTurbineBase< Viscosity >::drag_function

protectedinherited

Definition at line 98 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::Number GRINS::AveragedTurbineBase< Viscosity >::initial_speed

protectedinherited

Definition at line 122 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::AveragedTurbineBase< Viscosity >::lift_function

protectedinherited

Definition at line 97 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::AveragedTurbineBase< Viscosity >::local_vertical_function

protectedinherited

Definition at line 90 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::Number GRINS::AveragedTurbineBase< Viscosity >::moment_of_inertia

protectedinherited

Definition at line 118 of file averaged_turbine_base.h.

template<class Viscosity >

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::AveragedTurbineBase< Viscosity >::torque_function

protectedinherited

Definition at line 114 of file averaged_turbine_base.h.

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

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

Public Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

template<class Viscosity> class GRINS::AveragedTurbineAdjointStabilization< Viscosity >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class Viscosity>
class GRINS::AveragedTurbineAdjointStabilization< Viscosity >