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