void 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
{
libMesh::Gradient grad_T = context.fixed_interior_gradient(this->_temp_vars.T(), qp);
libMesh::Tensor hess_T = context.fixed_interior_hessian(this->_temp_vars.T(), qp);
libMesh::RealGradient rhocpU( rho*Cp*context.fixed_interior_value(this->_flow_vars.u(), qp),
rho*Cp*context.fixed_interior_value(this->_flow_vars.v(), qp) );
if(this->_flow_vars.dim() == 3)
rhocpU(2) = rho*Cp*context.fixed_interior_value(this->_flow_vars.w(), 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;
}
void AveragedTurbine<Mu>::nonlocal_time_derivative(bool compute_jacobian,
AssemblyContext& context,
CachedValues& /* cache */ )
{
libMesh::DenseSubMatrix<libMesh::Number> &Kss =
context.get_elem_jacobian(this->fan_speed_var(), this->fan_speed_var()); // R_{s},{s}
libMesh::DenseSubVector<libMesh::Number> &Fs =
context.get_elem_residual(this->fan_speed_var()); // R_{s}
const std::vector<libMesh::dof_id_type>& dof_indices =
context.get_dof_indices(this->fan_speed_var());
const libMesh::Number fan_speed =
context.get_system().current_solution(dof_indices[0]);
const libMesh::Number output_torque =
this->torque_function(libMesh::Point(0), fan_speed);
Fs(0) += output_torque;
if (compute_jacobian)
{
// FIXME: we should replace this FEM with a hook to the AD fparser stuff
const libMesh::Number epsilon = 1e-6;
const libMesh::Number output_torque_deriv =
(this->torque_function(libMesh::Point(0), fan_speed+epsilon) -
this->torque_function(libMesh::Point(0), fan_speed-epsilon)) / (2*epsilon);
Kss(0,0) += output_torque_deriv * context.get_elem_solution_derivative();
}
return;
}
void BoundaryConditions::apply_neumann_normal( AssemblyContext& context,
const VariableIndex var,
const libMesh::Real sign,
const FEShape& value ) const
{
libMesh::FEGenericBase<FEShape>* side_fe = NULL;
context.get_side_fe( var, side_fe );
// The number of local degrees of freedom in each variable.
const unsigned int n_var_dofs = context.get_dof_indices(var).size();
// Element Jacobian * quadrature weight for side integration.
const std::vector<libMesh::Real> &JxW_side = side_fe->get_JxW();
// The var shape functions at side quadrature points.
const std::vector<std::vector<FEShape> >& var_phi_side = side_fe->get_phi();
libMesh::DenseSubVector<libMesh::Number> &F_var = context.get_elem_residual(var); // residual
unsigned int n_qpoints = context.get_side_qrule().n_points();
for (unsigned int qp=0; qp != n_qpoints; qp++)
{
for (unsigned int i=0; i != n_var_dofs; i++)
{
F_var(i) += sign*value*var_phi_side[i][qp]*JxW_side[qp];
}
}
return;
}
void BoussinesqBuoyancyAdjointStabilization<Mu>::init_context( AssemblyContext& context )
{
context.get_element_fe(this->_flow_vars.p_var())->get_dphi();
context.get_element_fe(this->_flow_vars.u_var())->get_dphi();
context.get_element_fe(this->_flow_vars.u_var())->get_d2phi();
return;
}
void LowMachNavierStokesSPGSMStabilization<Mu,SH,TC>::assemble_energy_mass_residual( bool /*compute_jacobian*/,
AssemblyContext& context )
{
// The number of local degrees of freedom in each variable.
const unsigned int n_T_dofs = context.get_dof_indices(this->_temp_vars.T()).size();
// Element Jacobian * quadrature weights for interior integration.
const std::vector<libMesh::Real> &JxW =
context.get_element_fe(this->_temp_vars.T())->get_JxW();
// The temperature shape functions gradients at interior quadrature points.
const std::vector<std::vector<libMesh::RealGradient> >& T_gradphi =
context.get_element_fe(this->_temp_vars.T())->get_dphi();
libMesh::DenseSubVector<libMesh::Number> &FT = context.get_elem_residual(this->_temp_vars.T()); // R_{T}
unsigned int n_qpoints = context.get_element_qrule().n_points();
for (unsigned int qp=0; qp != n_qpoints; qp++)
{
libMesh::Number u, v;
u = context.fixed_interior_value(this->_flow_vars.u(), qp);
v = context.fixed_interior_value(this->_flow_vars.v(), qp);
libMesh::Gradient grad_T = context.fixed_interior_gradient(this->_temp_vars.T(), qp);
libMesh::NumberVectorValue U(u,v);
if (this->mesh_dim(context) == 3)
U(2) = context.fixed_interior_value(this->_flow_vars.w(), qp); // w
libMesh::Real T = context.fixed_interior_value( this->_temp_vars.T(), qp );
libMesh::Real rho = this->rho( T, this->get_p0_transient( context, qp ) );
libMesh::Real k = this->_k(T);
libMesh::Real cp = this->_cp(T);
libMesh::Number rho_cp = rho*this->_cp(T);
libMesh::FEBase* fe = context.get_element_fe(this->_flow_vars.u());
libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );
libMesh::Real tau_E = this->_stab_helper.compute_tau_energy( context, qp, g, G, rho, U, k, cp, false );
libMesh::Real RE_t = this->compute_res_energy_transient( context, qp );
for (unsigned int i=0; i != n_T_dofs; i++)
{
FT(i) -= rho_cp*tau_E*RE_t*U*T_gradphi[i][qp]*JxW[qp];
}
}
return;
}
void VelocityPenaltyAdjointStabilization<Mu>::init_context( AssemblyContext& context )
{
context.get_element_fe(this->_press_var.p())->get_dphi();
context.get_element_fe(this->_flow_vars.u())->get_xyz();
context.get_element_fe(this->_flow_vars.u())->get_phi();
context.get_element_fe(this->_flow_vars.u())->get_dphi();
context.get_element_fe(this->_flow_vars.u())->get_d2phi();
return;
}
void ReactingLowMachNavierStokesStabilizationBase<Mixture,Evaluator>::init_context( AssemblyContext& context )
{
// First call base class
ReactingLowMachNavierStokesAbstract::init_context(context);
// We need pressure derivatives
context.get_element_fe(this->_press_var.p())->get_dphi();
// We also need second derivatives, so initialize those.
context.get_element_fe(this->_flow_vars.u())->get_d2phi();
context.get_element_fe(this->_temp_vars.T())->get_d2phi();
}
void LowMachNavierStokes<Mu,SH,TC>::assemble_mass_time_deriv( bool /*compute_jacobian*/,
AssemblyContext& context,
CachedValues& cache )
{
// The number of local degrees of freedom in each variable.
const unsigned int n_p_dofs = context.get_dof_indices(this->_p_var).size();
// Element Jacobian * quadrature weights for interior integration.
const std::vector<libMesh::Real> &JxW =
context.get_element_fe(this->_u_var)->get_JxW();
// The pressure shape functions at interior quadrature points.
const std::vector<std::vector<libMesh::Real> >& p_phi =
context.get_element_fe(this->_p_var)->get_phi();
libMesh::DenseSubVector<libMesh::Number> &Fp = context.get_elem_residual(this->_p_var); // R_{p}
unsigned int n_qpoints = context.get_element_qrule().n_points();
for (unsigned int qp=0; qp != n_qpoints; qp++)
{
libMesh::Number u, v, T;
u = cache.get_cached_values(Cache::X_VELOCITY)[qp];
v = cache.get_cached_values(Cache::Y_VELOCITY)[qp];
T = cache.get_cached_values(Cache::TEMPERATURE)[qp];
libMesh::Gradient grad_u = cache.get_cached_gradient_values(Cache::X_VELOCITY_GRAD)[qp];
libMesh::Gradient grad_v = cache.get_cached_gradient_values(Cache::Y_VELOCITY_GRAD)[qp];
libMesh::Gradient grad_T = cache.get_cached_gradient_values(Cache::TEMPERATURE_GRAD)[qp];
libMesh::NumberVectorValue U(u,v);
if (this->_dim == 3)
U(2) = cache.get_cached_values(Cache::Z_VELOCITY)[qp]; // w
libMesh::Number divU = grad_u(0) + grad_v(1);
if (this->_dim == 3)
{
libMesh::Gradient grad_w = cache.get_cached_gradient_values(Cache::Z_VELOCITY_GRAD)[qp];
divU += grad_w(2);
}
// Now a loop over the pressure degrees of freedom. This
// computes the contributions of the continuity equation.
for (unsigned int i=0; i != n_p_dofs; i++)
{
Fp(i) += (-U*grad_T/T + divU)*p_phi[i][qp]*JxW[qp];
}
}
return;
}
void IncompressibleNavierStokesStabilizationBase<Mu>::init_context( AssemblyContext& context )
{
// First call base class
IncompressibleNavierStokesBase<Mu>::init_context(context);
// We need pressure derivatives
context.get_element_fe(this->_flow_vars.p_var())->get_dphi();
// We also need second derivatives, so initialize those.
context.get_element_fe(this->_flow_vars.u_var())->get_d2phi();
return;
}
void AverageNusseltNumber::side_qoi_derivative( AssemblyContext& context,
const unsigned int qoi_index )
{
for( std::set<libMesh::boundary_id_type>::const_iterator id = _bc_ids.begin();
id != _bc_ids.end(); id++ )
{
if( context.has_side_boundary_id( (*id) ) )
{
libMesh::FEBase* T_side_fe;
context.get_side_fe<libMesh::Real>(this->_T_var, T_side_fe);
const std::vector<libMesh::Real> &JxW = T_side_fe->get_JxW();
const std::vector<libMesh::Point>& normals = T_side_fe->get_normals();
unsigned int n_qpoints = context.get_side_qrule().n_points();
const unsigned int n_T_dofs = context.get_dof_indices(_T_var).size();
const std::vector<std::vector<libMesh::Gradient> >& T_gradphi = T_side_fe->get_dphi();
libMesh::DenseSubVector<libMesh::Number>& dQ_dT =
context.get_qoi_derivatives(qoi_index, _T_var);
// Loop over quadrature points
for (unsigned int qp = 0; qp != n_qpoints; qp++)
{
// Get the solution value at the quadrature point
libMesh::Gradient grad_T = 0.0;
context.side_gradient(this->_T_var, qp, grad_T);
// Update the elemental increment dR for each qp
//qoi += (this->_scaling)*(this->_k)*(grad_T*normals[qp])*JxW[qp];
for( unsigned int i = 0; i != n_T_dofs; i++ )
{
dQ_dT(i) += _scaling*_k*T_gradphi[i][qp]*normals[qp]*JxW[qp];
}
} // quadrature loop
} // end check on boundary id
}
return;
}
void HeatConduction<K>::mass_residual( bool compute_jacobian,
AssemblyContext& context,
CachedValues& /*cache*/ )
{
// First we get some references to cell-specific data that
// will be used to assemble the linear system.
// Element Jacobian * quadrature weights for interior integration
const std::vector<libMesh::Real> &JxW =
context.get_element_fe(_temp_vars.T_var())->get_JxW();
// The shape functions at interior quadrature points.
const std::vector<std::vector<libMesh::Real> >& phi =
context.get_element_fe(_temp_vars.T_var())->get_phi();
// The number of local degrees of freedom in each variable
const unsigned int n_T_dofs = context.get_dof_indices(_temp_vars.T_var()).size();
// The subvectors and submatrices we need to fill:
libMesh::DenseSubVector<libMesh::Real> &F =
context.get_elem_residual(_temp_vars.T_var());
libMesh::DenseSubMatrix<libMesh::Real> &M =
context.get_elem_jacobian(_temp_vars.T_var(), _temp_vars.T_var());
unsigned int n_qpoints = context.get_element_qrule().n_points();
for (unsigned int qp = 0; qp != n_qpoints; ++qp)
{
// For the mass residual, we need to be a little careful.
// The time integrator is handling the time-discretization
// for us so we need to supply M(u_fixed)*u' for the residual.
// u_fixed will be given by the fixed_interior_value function
// while u' will be given by the interior_rate function.
libMesh::Real T_dot;
context.interior_rate(_temp_vars.T_var(), qp, T_dot);
for (unsigned int i = 0; i != n_T_dofs; ++i)
{
F(i) -= JxW[qp]*(_rho*_Cp*T_dot*phi[i][qp] );
if( compute_jacobian )
{
for (unsigned int j=0; j != n_T_dofs; j++)
{
// We're assuming rho, cp are constant w.r.t. T here.
M(i,j) -=
context.get_elem_solution_rate_derivative()
* JxW[qp]*_rho*_Cp*phi[j][qp]*phi[i][qp] ;
}
}// End of check on Jacobian
} // End of element dof loop
} // End of the quadrature point loop
return;
}
void LowMachNavierStokes<Mu,SH,TC>::assemble_thermo_press_side_time_deriv( bool /*compute_jacobian*/,
AssemblyContext& context )
{
// The number of local degrees of freedom in each variable.
const unsigned int n_p0_dofs = context.get_dof_indices(this->_p0_var).size();
// Element Jacobian * quadrature weight for side integration.
//const std::vector<libMesh::Real> &JxW_side = context.get_side_fe(this->_T_var)->get_JxW();
//const std::vector<Point> &normals = context.get_side_fe(this->_T_var)->get_normals();
//libMesh::DenseSubVector<libMesh::Number> &F_p0 = context.get_elem_residual(this->_p0_var); // residual
// Physical location of the quadrature points
//const std::vector<libMesh::Point>& qpoint = context.get_side_fe(this->_T_var)->get_xyz();
unsigned int n_qpoints = context.get_side_qrule().n_points();
for (unsigned int qp=0; qp != n_qpoints; qp++)
{
/*
libMesh::Number T = context.side_value( this->_T_var, qp );
libMesh::Gradient U = ( context.side_value( this->_u_var, qp ),
context.side_value( this->_v_var, qp ) );
libMesh::Gradient grad_T = context.side_gradient( this->_T_var, qp );
libMesh::Number p0 = context.side_value( this->_p0_var, qp );
libMesh::Number k = this->_k(T);
libMesh::Number cp = this->_cp(T);
libMesh::Number cv = cp + this->_R;
libMesh::Number gamma = cp/cv;
libMesh::Number gamma_ratio = gamma/(gamma-1.0);
*/
//std::cout << "U = " << U << std::endl;
//std::cout << "x = " << qpoint[qp] << ", grad_T = " << grad_T << std::endl;
for (unsigned int i=0; i != n_p0_dofs; i++)
{
//F_p0(i) += (k*grad_T*normals[qp] - p0*gamma_ratio*U*normals[qp] )*JxW_side[qp];
}
}
return;
}
libMesh::Real HeatTransferStabilizationHelper::compute_res_energy_steady( AssemblyContext& context,
unsigned int qp,
const libMesh::Real rho,
const libMesh::Real Cp,
const libMesh::Real k ) const
{
libMesh::Gradient grad_T = context.fixed_interior_gradient(this->_temp_vars.T(), qp);
libMesh::Tensor hess_T = context.fixed_interior_hessian(this->_temp_vars.T(), qp);
libMesh::RealGradient rhocpU( rho*Cp*context.fixed_interior_value(this->_flow_vars.u(), qp),
rho*Cp*context.fixed_interior_value(this->_flow_vars.v(), qp) );
if(this->_flow_vars.dim() == 3)
rhocpU(2) = rho*Cp*context.fixed_interior_value(this->_flow_vars.w(), qp);
return rhocpU*grad_T - k*(hess_T(0,0) + hess_T(1,1) + hess_T(2,2));
}
void ParsedVelocitySource<Mu>::init_context( AssemblyContext& context )
{
context.get_element_fe(this->_flow_vars.u())->get_xyz();
context.get_element_fe(this->_flow_vars.u())->get_phi();
return;
}
void AveragedTurbine<Mu>::init_context( AssemblyContext& context )
{
context.get_element_fe(this->_flow_vars.u_var())->get_xyz();
context.get_element_fe(this->_flow_vars.u_var())->get_phi();
return;
}
void VelocityPenalty<Mu>::init_context( AssemblyContext& context )
{
context.get_element_fe(this->_flow_vars.u_var())->get_xyz();
context.get_element_fe(this->_flow_vars.u_var())->get_phi();
return;
}
void LowMachNavierStokesSPGSMStabilization<Mu,SH,TC>::assemble_continuity_time_deriv( bool /*compute_jacobian*/,
AssemblyContext& context )
{
// The number of local degrees of freedom in each variable.
const unsigned int n_p_dofs = context.get_dof_indices(this->_press_var.p()).size();
// Element Jacobian * quadrature weights for interior integration.
const std::vector<libMesh::Real> &JxW =
context.get_element_fe(this->_flow_vars.u())->get_JxW();
// The pressure shape functions at interior quadrature points.
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}
unsigned int n_qpoints = context.get_element_qrule().n_points();
for (unsigned int qp=0; qp != n_qpoints; qp++)
{
libMesh::FEBase* fe = context.get_element_fe(this->_flow_vars.u());
libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );
libMesh::Real T = context.interior_value( this->_temp_vars.T(), qp );
libMesh::Real mu = this->_mu(T);
libMesh::Real rho = this->rho( T, this->get_p0_steady( context, qp ) );
libMesh::RealGradient U( context.interior_value( this->_flow_vars.u(), qp ),
context.interior_value( this->_flow_vars.v(), qp ) );
if( this->mesh_dim(context) == 3 )
U(2) = context.interior_value( this->_flow_vars.w(), qp );
libMesh::Real tau_M = this->_stab_helper.compute_tau_momentum( context, qp, g, G, rho, U, mu, this->_is_steady );
libMesh::RealGradient RM_s = this->compute_res_momentum_steady( context, qp );
// Now a loop over the pressure degrees of freedom. This
// computes the contributions of the continuity equation.
for (unsigned int i=0; i != n_p_dofs; i++)
{
Fp(i) += tau_M*RM_s*p_dphi[i][qp]*JxW[qp];
}
}
return;
}
void SpalartAllmarasStabilizationBase<Mu>::init_context( AssemblyContext& context )
{
// First call base class
SpalartAllmaras<Mu>::init_context(context);
// We also need second derivatives, so initialize those.
context.get_element_fe(this->_turbulence_vars.nu())->get_d2phi();
}
libMesh::Real HeatTransferStabilizationHelper::compute_res_energy_transient( AssemblyContext& context,
unsigned int qp,
const libMesh::Real rho,
const libMesh::Real Cp ) const
{
libMesh::Real T_dot = context.interior_value(this->_temp_vars.T_var(), qp);
return rho*Cp*T_dot;
}
void ConstantSourceTerm::element_time_derivative
( bool /*compute_jacobian*/, AssemblyContext & context )
{
for( std::vector<VariableIndex>::const_iterator v_it = _vars.begin();
v_it != _vars.end(); ++v_it )
{
VariableIndex var = *v_it;
// The number of local degrees of freedom in each variable.
const unsigned int n_dofs = context.get_dof_indices(var).size();
// Element Jacobian * quadrature weights for interior integration.
const std::vector<libMesh::Real> &JxW =
context.get_element_fe(var)->get_JxW();
// The temperature shape functions at interior quadrature points.
const std::vector<std::vector<libMesh::Real> >& phi =
context.get_element_fe(var)->get_phi();
// Get residuals
libMesh::DenseSubVector<libMesh::Number> &F_var = context.get_elem_residual(var);
// 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();
for (unsigned int qp=0; qp != n_qpoints; qp++)
{
for (unsigned int i=0; i != n_dofs; i++)
{
F_var(i) += (this->_value)*phi[i][qp]*JxW[qp];
}
}
} // Variable loop
return;
}
void HeatTransferSPGSMStabilization<K>::element_time_derivative
( bool compute_jacobian, AssemblyContext & context )
{
// The number of local degrees of freedom in each variable.
const unsigned int n_T_dofs = context.get_dof_indices(this->_temp_vars.T()).size();
// Element Jacobian * quadrature weights for interior integration.
const std::vector<libMesh::Real> &JxW =
context.get_element_fe(this->_temp_vars.T())->get_JxW();
const std::vector<std::vector<libMesh::RealGradient> >& T_gradphi =
context.get_element_fe(this->_temp_vars.T())->get_dphi();
libMesh::DenseSubVector<libMesh::Number> &FT = context.get_elem_residual(this->_temp_vars.T()); // R_{T}
libMesh::FEBase* fe = context.get_element_fe(this->_temp_vars.T());
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(), qp ),
context.interior_value( this->_flow_vars.v(), qp ) );
if( this->_flow_vars.dim() == 3 )
{
U(2) = context.interior_value( this->_flow_vars.w(), qp );
}
// Compute Conductivity at this qp
libMesh::Real _k_qp = this->_k(context, qp);
libMesh::Real tau_E = this->_stab_helper.compute_tau_energy( context, G, this->_rho, this->_Cp, _k_qp, U, this->_is_steady );
libMesh::Real RE_s = this->_stab_helper.compute_res_energy_steady( context, qp, this->_rho, this->_Cp, _k_qp );
for (unsigned int i=0; i != n_T_dofs; i++)
{
FT(i) += -tau_E*RE_s*this->_rho*this->_Cp*U*T_gradphi[i][qp]*JxW[qp];
}
if( compute_jacobian )
{
libmesh_not_implemented();
}
}
}
void AverageNusseltNumber::side_qoi( AssemblyContext& context,
const unsigned int qoi_index )
{
bool on_correct_side = false;
for (std::set<libMesh::boundary_id_type>::const_iterator id =
_bc_ids.begin(); id != _bc_ids.end(); id++ )
if( context.has_side_boundary_id( (*id) ) )
{
on_correct_side = true;
break;
}
if (!on_correct_side)
return;
libMesh::FEBase* side_fe;
context.get_side_fe<libMesh::Real>(this->_T_var, side_fe);
const std::vector<libMesh::Real> &JxW = side_fe->get_JxW();
const std::vector<libMesh::Point>& normals = side_fe->get_normals();
unsigned int n_qpoints = context.get_side_qrule().n_points();
libMesh::Number& qoi = context.get_qois()[qoi_index];
// Loop over quadrature points
for (unsigned int qp = 0; qp != n_qpoints; qp++)
{
// Get the solution value at the quadrature point
libMesh::Gradient grad_T = 0.0;
context.side_gradient(this->_T_var, qp, grad_T);
// Update the elemental increment dR for each qp
qoi += (this->_scaling)*(this->_k)*(grad_T*normals[qp])*JxW[qp];
} // quadrature loop
}
void ParsedInteriorQoI::element_qoi( AssemblyContext& context,
const unsigned int qoi_index )
{
libMesh::FEBase* element_fe;
context.get_element_fe<libMesh::Real>(0, element_fe);
const std::vector<libMesh::Real> &JxW = element_fe->get_JxW();
const std::vector<libMesh::Point>& x_qp = element_fe->get_xyz();
unsigned int n_qpoints = context.get_element_qrule().n_points();
/*! \todo Need to generalize this to the multiple QoI case */
libMesh::Number& qoi = context.get_qois()[qoi_index];
for( unsigned int qp = 0; qp != n_qpoints; qp++ )
{
const libMesh::Number func_val =
(*qoi_functional)(context, x_qp[qp], context.get_time());
qoi += func_val * JxW[qp];
}
}
void 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
{
libMesh::Real T_dot = context.interior_value(this->_temp_vars.T_var(), qp);
res = rho*Cp*T_dot;
d_res_dTdot = rho*Cp;
}
libMesh::UniquePtr<libMesh::DiffContext> MultiphysicsSystem::build_context()
{
AssemblyContext* context = new AssemblyContext(*this);
libMesh::UniquePtr<libMesh::DiffContext> ap(context);
libMesh::DifferentiablePhysics* phys = libMesh::FEMSystem::get_physics();
libmesh_assert(phys);
// If we are solving a moving mesh problem, tell that to the Context
context->set_mesh_system(phys->get_mesh_system());
context->set_mesh_x_var(phys->get_mesh_x_var());
context->set_mesh_y_var(phys->get_mesh_y_var());
context->set_mesh_z_var(phys->get_mesh_z_var());
ap->set_deltat_pointer( &deltat );
// If we are solving the adjoint problem, tell that to the Context
ap->is_adjoint() = this->get_time_solver().is_adjoint();
return ap;
}
void PracticeCDRinv::init_context( AssemblyContext& context){
context.get_element_fe(_c_var)->get_JxW();
context.get_element_fe(_c_var)->get_phi();
context.get_element_fe(_c_var)->get_dphi();
context.get_element_fe(_c_var)->get_xyz();
context.get_side_fe(_c_var)->get_JxW();
context.get_side_fe(_c_var)->get_phi();
context.get_side_fe(_c_var)->get_dphi();
context.get_side_fe(_c_var)->get_xyz();
return;
}
void AveragedTurbine<Mu>::nonlocal_mass_residual( bool compute_jacobian,
AssemblyContext& context,
CachedValues& /* cache */ )
{
libMesh::DenseSubMatrix<libMesh::Number> &Kss =
context.get_elem_jacobian(this->fan_speed_var(), this->fan_speed_var()); // R_{s},{s}
libMesh::DenseSubVector<libMesh::Number> &Fs =
context.get_elem_residual(this->fan_speed_var()); // R_{s}
const libMesh::DenseSubVector<libMesh::Number> &Us =
context.get_elem_solution_rate(this->fan_speed_var());
const libMesh::Number& fan_speed = Us(0);
Fs(0) -= this->moment_of_inertia * fan_speed;
if (compute_jacobian)
{
Kss(0,0) -= this->moment_of_inertia * context.get_elem_solution_rate_derivative();
}
return;
}
void LowMachNavierStokes<Mu,SH,TC>::assemble_thermo_press_elem_time_deriv( bool /*compute_jacobian*/,
AssemblyContext& context )
{
// Element Jacobian * quadrature weights for interior integration
const std::vector<libMesh::Real> &JxW =
context.get_element_fe(this->_T_var)->get_JxW();
// The number of local degrees of freedom in each variable
const unsigned int n_p0_dofs = context.get_dof_indices(this->_p0_var).size();
// The subvectors and submatrices we need to fill:
libMesh::DenseSubVector<libMesh::Real> &F_p0 = context.get_elem_residual(this->_p0_var);
unsigned int n_qpoints = context.get_element_qrule().n_points();
for (unsigned int qp = 0; qp != n_qpoints; ++qp)
{
libMesh::Number T;
T = context.interior_value(this->_T_var, qp);
libMesh::Gradient grad_u, grad_v, grad_w;
grad_u = context.interior_gradient(this->_u_var, qp);
grad_v = context.interior_gradient(this->_v_var, qp);
if (this->_dim == 3)
grad_w = context.interior_gradient(this->_w_var, qp);
libMesh::Number divU = grad_u(0) + grad_v(1);
if(this->_dim==3)
divU += grad_w(2);
//libMesh::Number cp = this->_cp(T);
//libMesh::Number cv = cp + this->_R;
//libMesh::Number gamma = cp/cv;
//libMesh::Number gamma_ratio = gamma/(gamma-1.0);
libMesh::Number p0 = context.interior_value( this->_p0_var, qp );
for (unsigned int i = 0; i != n_p0_dofs; ++i)
{
F_p0(i) += (p0/T - this->_p0/this->_T0)*JxW[qp];
//F_p0(i) -= p0*gamma_ratio*divU*JxW[qp];
} // End DoF loop i
}
return;
}
libMesh::RealGradient StabilizationHelper::compute_g( libMesh::FEBase* fe,
AssemblyContext& c,
unsigned int qp ) const
{
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;
}
void MultiphysicsSystem::compute_postprocessed_quantity( unsigned int quantity_index,
const AssemblyContext& context,
const libMesh::Point& point,
libMesh::Real& value )
{
for( PhysicsListIter physics_iter = _physics_list.begin();
physics_iter != _physics_list.end();
physics_iter++ )
{
// Only compute if physics is active on current subdomain or globally
if( (physics_iter->second)->enabled_on_elem( &context.get_elem() ) )
{
(physics_iter->second)->compute_postprocessed_quantity( quantity_index, context, point, value );
}
}
return;
}
