GRINS::HeatTransferStabilizationHelper Class Reference

#include <heat_transfer_stab_helper.h>

Inheritance diagram for GRINS::HeatTransferStabilizationHelper:

Collaboration diagram for GRINS::HeatTransferStabilizationHelper:

Public Member Functions
	HeatTransferStabilizationHelper (const std::string &helper_name, const GetPot &input)
	~HeatTransferStabilizationHelper ()
void	init (libMesh::FEMSystem &system)
libMesh::Real	compute_res_energy_steady (AssemblyContext &context, unsigned int qp, const libMesh::Real rho, const libMesh::Real Cp, const libMesh::Real k) const
void	compute_res_energy_steady_and_derivs (AssemblyContext &context, unsigned int qp, const libMesh::Real rho, const libMesh::Real Cp, const libMesh::Real k, libMesh::Real &res, libMesh::Real &d_res_dT, libMesh::Gradient &d_res_dgradT, libMesh::Tensor &d_res_dhessT, libMesh::Gradient &d_res_dU) const
libMesh::Real	compute_res_energy_transient (AssemblyContext &context, unsigned int qp, const libMesh::Real rho, const libMesh::Real Cp) const
void	compute_res_energy_transient_and_derivs (AssemblyContext &context, unsigned int qp, const libMesh::Real rho, const libMesh::Real Cp, libMesh::Real &res, libMesh::Real &d_res_dTdot) const
libMesh::Real	compute_tau_energy (AssemblyContext &c, libMesh::RealTensor &G, libMesh::Real rho, libMesh::Real cp, libMesh::Real k, libMesh::Gradient U, bool is_steady) const
void	compute_tau_energy_and_derivs (AssemblyContext &c, libMesh::RealTensor &G, libMesh::Real rho, libMesh::Real cp, libMesh::Real k, libMesh::Gradient U, libMesh::Real &tau_E, libMesh::Real &d_tau_E_d_rho, libMesh::Gradient &d_tau_E_d_U, bool is_steady) 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
libMesh::Real	_C
libMesh::Real	_tau_factor
PrimitiveTempVariables	_temp_vars
PrimitiveFlowVariables	_flow_vars

Detailed Description

Definition at line 39 of file heat_transfer_stab_helper.h.

Constructor & Destructor Documentation

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

Definition at line 38 of file heat_transfer_stab_helper.C.

    : StabilizationHelper(helper_name),
      _C(1),
      _tau_factor(0.5),
      _temp_vars(input),
      _flow_vars(input)
  {
    if (input.have_variable("Stabilization/tau_constant_T"))
      this->set_parameter
        (_C, input, "Stabilization/tau_constant_T", _C );
    else
      this->set_parameter
        (_C, input, "Stabilization/tau_constant", _C );

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

GRINS::HeatTransferStabilizationHelper::~HeatTransferStabilizationHelper

(

)

Definition at line 61 of file heat_transfer_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::HeatTransferStabilizationHelper::compute_res_energy_steady	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho,
		const libMesh::Real	Cp,
		const libMesh::Real	k
	)		const

Definition at line 74 of file heat_transfer_stab_helper.C.

References _flow_vars, _temp_vars, GRINS::PrimitiveTempVariables::T_var(), and GRINS::PrimitiveFlowVariables::w_var().

  {
    libMesh::Gradient grad_T = context.fixed_interior_gradient(this->_temp_vars.T_var(), qp);
    libMesh::Tensor hess_T = context.fixed_interior_hessian(this->_temp_vars.T_var(), qp);

    libMesh::RealGradient rhocpU( rho*Cp*context.fixed_interior_value(this->_flow_vars.u_var(), qp), 
                                  rho*Cp*context.fixed_interior_value(this->_flow_vars.v_var(), qp) );
    if(context.get_system().get_mesh().mesh_dimension() == 3)
      rhocpU(2) = rho*Cp*context.fixed_interior_value(this->_flow_vars.w_var(), qp);

    return rhocpU*grad_T - k*(hess_T(0,0) + hess_T(1,1) + hess_T(2,2));
  }

void GRINS::HeatTransferStabilizationHelper::compute_res_energy_steady_and_derivs	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho,
		const libMesh::Real	Cp,
		const libMesh::Real	k,
		libMesh::Real &	res,
		libMesh::Real &	d_res_dT,
		libMesh::Gradient &	d_res_dgradT,
		libMesh::Tensor &	d_res_dhessT,
		libMesh::Gradient &	d_res_dU
	)		const

Definition at line 92 of file heat_transfer_stab_helper.C.

  {
    libMesh::Gradient grad_T = context.fixed_interior_gradient(this->_temp_vars.T_var(), qp);
    libMesh::Tensor hess_T = context.fixed_interior_hessian(this->_temp_vars.T_var(), qp);

    libMesh::RealGradient rhocpU( rho*Cp*context.fixed_interior_value(this->_flow_vars.u_var(), qp), 
                                  rho*Cp*context.fixed_interior_value(this->_flow_vars.v_var(), qp) );
    if(context.get_system().get_mesh().mesh_dimension() == 3)
      rhocpU(2) = rho*Cp*context.fixed_interior_value(this->_flow_vars.w_var(), qp);

    res = rhocpU*grad_T - k*(hess_T(0,0) + hess_T(1,1) + hess_T(2,2));
    d_res_dT = 0;
    d_res_dgradT = rhocpU;
    d_res_dhessT = 0;
    d_res_dhessT(0,0) = -k;
    d_res_dhessT(1,1) = -k;
    d_res_dhessT(2,2) = -k;
    d_res_dU = rho * Cp * grad_T;
  }

libMesh::Real GRINS::HeatTransferStabilizationHelper::compute_res_energy_transient	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho,
		const libMesh::Real	Cp
	)		const

Definition at line 123 of file heat_transfer_stab_helper.C.

References _temp_vars, and GRINS::PrimitiveTempVariables::T_var().

  {
    libMesh::Real T_dot;
    context.interior_rate(this->_temp_vars.T_var(), qp, T_dot);

    return rho*Cp*T_dot;
  }

void GRINS::HeatTransferStabilizationHelper::compute_res_energy_transient_and_derivs	(	AssemblyContext &	context,
		unsigned int	qp,
		const libMesh::Real	rho,
		const libMesh::Real	Cp,
		libMesh::Real &	res,
		libMesh::Real &	d_res_dTdot
	)		const

Definition at line 136 of file heat_transfer_stab_helper.C.

  {
    libMesh::Real T_dot;
    context.interior_rate(this->_temp_vars.T_var(), qp, T_dot);

    res = rho*Cp*T_dot;
    d_res_dTdot = rho*Cp;
  }

libMesh::Real GRINS::HeatTransferStabilizationHelper::compute_tau_energy ( AssemblyContext &  c, libMesh::RealTensor &  G, libMesh::Real  rho, libMesh::Real  cp, libMesh::Real  k, libMesh::Gradient  U, bool  is_steady  ) const

inline

Definition at line 115 of file heat_transfer_stab_helper.h.

References _C, and _tau_factor.

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

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

void GRINS::HeatTransferStabilizationHelper::compute_tau_energy_and_derivs ( AssemblyContext &  c, libMesh::RealTensor &  G, libMesh::Real  rho, libMesh::Real  cp, libMesh::Real  k, libMesh::Gradient  U, libMesh::Real &  tau_E, libMesh::Real &  d_tau_E_d_rho, libMesh::Gradient &  d_tau_E_d_U, bool  is_steady  ) const

inline

Definition at line 134 of file heat_transfer_stab_helper.h.

  {
    libMesh::Gradient rhocpU = rho*cp*U;
    libMesh::Gradient GrhocpU = G*rhocpU;
    libMesh::Real rhocpUGrhocpU = rhocpU * GrhocpU;
    libMesh::Real GG = G.contract(G);
    tau_E = (rhocpU)*(GrhocpU) + this->_C*k*k*GG;
    d_tau_E_d_rho = rhocpUGrhocpU*2/rho/cp;
    d_tau_E_d_U = 2*rho*cp*GrhocpU;
    
    if(!is_steady)
      {
        libMesh::Real two_rhocp_over_dt = 2*rho*cp/c.get_deltat_value();
        tau_E += two_rhocp_over_dt * two_rhocp_over_dt;
        d_tau_E_d_rho += 4*two_rhocp_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_E);
    libMesh::Real d_tau_d_oldtau = -this->_tau_factor / (tau_E*root_oldtau) / 2;

    d_tau_E_d_rho         = d_tau_d_oldtau * d_tau_E_d_rho;
    d_tau_E_d_U           = d_tau_d_oldtau * d_tau_E_d_U;

    tau_E = this->_tau_factor / root_oldtau;
  }

void GRINS::HeatTransferStabilizationHelper::init

(

libMesh::FEMSystem &

system

)

Definition at line 66 of file heat_transfer_stab_helper.C.

References _flow_vars, _temp_vars, GRINS::PrimitiveTempVariables::init(), and GRINS::PrimitiveFlowVariables::init().

  {
    _temp_vars.init(&system);
    _flow_vars.init(&system);

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

Member Data Documentation

libMesh::Real GRINS::HeatTransferStabilizationHelper::_C

protected

Definition at line 105 of file heat_transfer_stab_helper.h.

Referenced by compute_tau_energy().

PrimitiveFlowVariables GRINS::HeatTransferStabilizationHelper::_flow_vars

protected

Definition at line 109 of file heat_transfer_stab_helper.h.

Referenced by compute_res_energy_steady(), and init().

libMesh::Real GRINS::HeatTransferStabilizationHelper::_tau_factor

protected

Definition at line 105 of file heat_transfer_stab_helper.h.

Referenced by compute_tau_energy().

PrimitiveTempVariables GRINS::HeatTransferStabilizationHelper::_temp_vars

protected

Definition at line 107 of file heat_transfer_stab_helper.h.

Referenced by compute_res_energy_steady(), compute_res_energy_transient(), and init().

---

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

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