void PorousFlowVariableBase::computeQpProperties() { // do we really need this stuff here? it seems very inefficient to keep resizing everything! _porepressure[_qp].resize(_num_phases); _dporepressure_dvar[_qp].resize(_num_phases); _saturation[_qp].resize(_num_phases); _dsaturation_dvar[_qp].resize(_num_phases); if (!_nodal_material) { (*_gradp_qp)[_qp].resize(_num_phases); (*_dgradp_qp_dgradv)[_qp].resize(_num_phases); (*_dgradp_qp_dv)[_qp].resize(_num_phases); (*_grads_qp)[_qp].resize(_num_phases); (*_dgrads_qp_dgradv)[_qp].resize(_num_phases); (*_dgrads_qp_dv)[_qp].resize(_num_phases); } /// Prepare the derivative matrices with zeroes for (unsigned phase = 0; phase < _num_phases; ++phase) { _dporepressure_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dsaturation_dvar[_qp][phase].assign(_num_pf_vars, 0.0); if (!_nodal_material) { (*_dgradp_qp_dgradv)[_qp][phase].assign(_num_pf_vars, 0.0); (*_dgradp_qp_dv)[_qp][phase].assign(_num_pf_vars, RealGradient()); (*_dgrads_qp_dgradv)[_qp][phase].assign(_num_pf_vars, 0.0); (*_dgrads_qp_dv)[_qp][phase].assign(_num_pf_vars, RealGradient()); } } }
void PorousFlowVolumetricStrain::computeQpProperties() { RankTwoTensor A( (*_grad_disp[0])[_qp], (*_grad_disp[1])[_qp], (*_grad_disp[2])[_qp]); // Deformation gradient RankTwoTensor Fbar((*_grad_disp_old[0])[_qp], (*_grad_disp_old[1])[_qp], (*_grad_disp_old[2])[_qp]); // Old Deformation gradient _vol_total_strain_qp[_qp] = A.trace(); A -= Fbar; // A = grad_disp - grad_disp_old RankTwoTensor total_strain_increment = 0.5 * (A + A.transpose()); const Real andy = (_consistent ? 1.0 + (*_grad_disp_old[0])[_qp](0) + (*_grad_disp_old[1])[_qp](1) + (*_grad_disp_old[2])[_qp](2) : 1.0); _vol_strain_rate_qp[_qp] = total_strain_increment.trace() / _dt / andy; // prepare the derivatives with zeroes _dvol_strain_rate_qp_dvar[_qp].resize(_num_var, RealGradient()); _dvol_total_strain_qp_dvar[_qp].resize(_num_var, RealGradient()); for (unsigned i = 0; i < _ndisp; ++i) if (_dictator.isPorousFlowVariable(_disp_var_num[i])) { // the i_th displacement is a porous-flow variable const unsigned int pvar = _dictator.porousFlowVariableNum(_disp_var_num[i]); _dvol_strain_rate_qp_dvar[_qp][pvar](i) = 1.0 / _dt / andy; _dvol_total_strain_qp_dvar[_qp][pvar](i) = 1.0; } }
RealGradient FE<2,NEDELEC_ONE>::shape_second_deriv(const Elem * elem, const Order order, const unsigned int libmesh_dbg_var(i), const unsigned int libmesh_dbg_var(j), const Point &) { #if LIBMESH_DIM > 1 libmesh_assert(elem); // j = 0 ==> d^2 phi / dxi^2 // j = 1 ==> d^2 phi / dxi deta // j = 2 ==> d^2 phi / deta^2 libmesh_assert_less (j, 3); const Order total_order = static_cast<Order>(order + elem->p_level()); switch (total_order) { // linear Lagrange shape functions case FIRST: { switch (elem->type()) { case QUAD8: case QUAD9: { libmesh_assert_less (i, 4); // All second derivatives for linear quads are zero. return RealGradient(); } case TRI6: { libmesh_assert_less (i, 3); // All second derivatives for linear triangles are zero. return RealGradient(); } default: libmesh_error_msg("ERROR: Unsupported 2D element type!: " << elem->type()); } // end switch (type) } // end case FIRST // unsupported order default: libmesh_error_msg("ERROR: Unsupported 2D FE order!: " << total_order); } // end switch (order) #endif // LIBMESH_DIM > 1 libmesh_error_msg("We'll never get here!"); return RealGradient(); }
void PorousFlowPorosityConst::initQpStatefulProperties() { _porosity_nodal[_qp] = _input_porosity; // this becomes _porosity_old[_qp] in the first call to computeQpProperties _porosity_qp[_qp] = _input_porosity; // this becomes _porosity_old[_qp] in the first call to computeQpProperties _dporosity_nodal_dvar[_qp].assign(_num_var, 0.0); _dporosity_qp_dvar[_qp].assign(_num_var, 0.0); _dporosity_nodal_dgradvar[_qp].assign(_num_var, RealGradient()); _dporosity_qp_dgradvar[_qp].assign(_num_var, RealGradient()); }
void PorousFlowPorosityConst::initQpStatefulProperties() { _porosity_nodal[_qp] = _input_porosity; _porosity_qp[_qp] = _input_porosity; // The derivatives are zero for all time _dporosity_nodal_dvar[_qp].assign(_num_var, 0.0); _dporosity_qp_dvar[_qp].assign(_num_var, 0.0); _dporosity_nodal_dgradvar[_qp].assign(_num_var, RealGradient()); _dporosity_qp_dgradvar[_qp].assign(_num_var, RealGradient()); }
void PorousFlowPorosityUnity::initQpStatefulProperties() { _porosity_nodal[_qp] = 1.0; _porosity_qp[_qp] = 1.0; const unsigned int num_var = _dictator_UO.numVariables(); _dporosity_nodal_dvar[_qp].assign(num_var, 0.0); _dporosity_qp_dvar[_qp].assign(num_var, 0.0); _dporosity_nodal_dgradvar[_qp].assign(num_var, RealGradient()); _dporosity_qp_dgradvar[_qp].assign(num_var, RealGradient()); }
void AEFVMaterial::computeQpProperties() { // initialize the variable _u[_qp] = _uc[_qp]; // interpolate variable values at face center if (_bnd) { // you should know how many equations you are solving and assign this number // e.g. = 1 (for the advection equation) unsigned int nvars = 1; std::vector<RealGradient> ugrad(nvars, RealGradient(0., 0., 0.)); ugrad = _lslope.getElementSlope(_current_elem->id()); // get the directional vector from cell center to face center RealGradient dvec = _q_point[_qp] - _current_elem->centroid(); // calculate the variable at face center _u[_qp] += ugrad[0] * dvec; // clear the temporary vectors ugrad.clear(); } // calculations only for elemental output else if (!_bnd) { } }
PotentialAdvection::PotentialAdvection(const InputParameters & parameters) : Kernel(parameters), _potential_id(coupled("potential")), _sgn(getParam<bool>("positive_charge") ? 1 : -1), _default(_fe_problem.getMaxQps(), RealGradient(-1.)), _grad_potential(isCoupled("potential") ? coupledGradient("potential") : _default) { }
RealGradient FE<3,NEDELEC_ONE>::shape(const ElemType, const Order, const unsigned int, const Point &) { libmesh_error_msg("Nedelec elements require the element type \nbecause edge orientation is needed."); return RealGradient(); }
void PorousFlowVariableBase::computeQpProperties() { /// Prepare the derivative matrices with zeroes for (unsigned phase = 0; phase < _num_phases; ++phase) { _dporepressure_nodal_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dporepressure_qp_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dgradp_qp_dgradv[_qp][phase].assign(_num_pf_vars, 0.0); _dgradp_qp_dv[_qp][phase].assign(_num_pf_vars, RealGradient()); _dsaturation_nodal_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dsaturation_qp_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dgrads_qp_dgradv[_qp][phase].assign(_num_pf_vars, 0.0); _dgrads_qp_dv[_qp][phase].assign(_num_pf_vars, RealGradient()); _dtemperature_nodal_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dtemperature_qp_dvar[_qp][phase].assign(_num_pf_vars, 0.0); } }
void PorousFlowPorosityConst::computeQpProperties() { initQpStatefulProperties(); // The derivatives are zero for all time _dporosity_dvar[_qp].assign(_num_var, 0.0); _dporosity_dgradvar[_qp].assign(_num_var, RealGradient()); }
void PorousFlow2PhasePP::initQpStatefulProperties() { PorousFlowVariableBase::initQpStatefulProperties(); buildQpPPSS(); /* * the derivatives of porepressure with respect to porepressure * remain fixed (at unity) throughout the simulation */ // prepare the derivative matrix with zeroes for (unsigned phase = 0; phase < _num_phases; ++phase) { _dporepressure_nodal_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dporepressure_qp_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dgradp_qp_dgradv[_qp][phase].assign(_num_pf_vars, 0.0); _dgradp_qp_dv[_qp][phase].assign(_num_pf_vars, RealGradient()); } if (_dictator_UO.isPorousFlowVariable(_phase0_porepressure_varnum)) { // _phase0_porepressure is a PorousFlow variable _dporepressure_nodal_dvar[_qp][0][_p0var] = 1.0; _dporepressure_qp_dvar[_qp][0][_p0var] = 1.0; _dgradp_qp_dgradv[_qp][0][_p0var] = 1.0; } if (_dictator_UO.isPorousFlowVariable(_phase1_porepressure_varnum)) { // _phase1_porepressure is a PorousFlow variable _dporepressure_nodal_dvar[_qp][1][_p1var] = 1.0; _dporepressure_qp_dvar[_qp][1][_p1var] = 1.0; _dgradp_qp_dgradv[_qp][1][_p1var] = 1.0; } // prepare the derivative matrix with zeroes for (unsigned phase = 0; phase < _num_phases; ++phase) { _dtemperature_nodal_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dtemperature_qp_dvar[_qp][phase].assign(_num_pf_vars, 0.0); } // _temperature is only dependent on _temperature, and its derivative is = 1 if (_dictator_UO.isPorousFlowVariable(_temperature_varnum)) { // _phase0_temperature is a porflow variable _dtemperature_nodal_dvar[_qp][0][_tvar] = 1.0; _dtemperature_nodal_dvar[_qp][1][_tvar] = 1.0; _dtemperature_qp_dvar[_qp][0][_tvar] = 1.0; _dtemperature_qp_dvar[_qp][1][_tvar] = 1.0; } }
RealGradient FE<2,NEDELEC_ONE>::shape(const ElemType, const Order, const unsigned int, const Point&) { #if LIBMESH_DIM > 1 libMesh::err << "Nedelec elements require the element type\n" << "because edge orientation is needed." << std::endl; libmesh_error(); #endif // LIBMESH_DIM > 1 libmesh_error(); return RealGradient(); }
void PorousFlow2PhasePP::computeQpProperties() { buildQpPPSS(); // prepare the derivative matrix with zeroes for (unsigned phase = 0; phase < _num_phases; ++phase) { _dsaturation_nodal_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dsaturation_qp_dvar[_qp][phase].assign(_num_pf_vars, 0.0); _dgrads_qp_dgradv[_qp][phase].assign(_num_pf_vars, 0.0); _dgrads_qp_dv[_qp][phase].assign(_num_pf_vars, RealGradient()); } const Real pc_nodal = _phase0_porepressure_nodal[_qp] - _phase1_porepressure_nodal[_qp]; // this is <= 0 const Real dseff_nodal = dEffectiveSaturation_dP(pc_nodal); // d(seff)/d(pc) const Real pc_qp = _phase0_porepressure_qp[_qp] - _phase1_porepressure_qp[_qp]; // this is <= 0 const Real dseff_qp = dEffectiveSaturation_dP(pc_qp); // d(seff_qp)/d(pc_qp) const Real d2seff_qp = d2EffectiveSaturation_dP2(pc_qp); // d^2(seff_qp)/d(pc_qp)^2 if (_dictator_UO.isPorousFlowVariable(_phase0_porepressure_varnum)) { _dsaturation_nodal_dvar[_qp][0][_p0var] = dseff_nodal; _dsaturation_qp_dvar[_qp][0][_p0var] = dseff_qp; _dgrads_qp_dgradv[_qp][0][_p0var] = dseff_qp; _dgrads_qp_dv[_qp][0][_p0var] = d2seff_qp * (_phase0_gradp_qp[_qp] - _phase1_gradp_qp[_qp]); _dsaturation_nodal_dvar[_qp][1][_p0var] = - dseff_nodal; _dsaturation_qp_dvar[_qp][1][_p0var] = - dseff_qp; _dgrads_qp_dgradv[_qp][1][_p0var] = - dseff_qp; _dgrads_qp_dv[_qp][1][_p0var] = - d2seff_qp * (_phase0_gradp_qp[_qp] - _phase1_gradp_qp[_qp]); } if (_dictator_UO.isPorousFlowVariable(_phase1_porepressure_varnum)) { _dsaturation_nodal_dvar[_qp][0][_p1var] = - dseff_nodal; _dsaturation_qp_dvar[_qp][0][_p1var] = - dseff_qp; _dgrads_qp_dgradv[_qp][0][_p1var] = - dseff_qp; _dgrads_qp_dv[_qp][0][_p1var] = - d2seff_qp * (_phase0_gradp_qp[_qp] - _phase1_gradp_qp[_qp]); _dsaturation_nodal_dvar[_qp][1][_p1var] = dseff_nodal; _dsaturation_qp_dvar[_qp][1][_p1var] = dseff_qp; _dgrads_qp_dgradv[_qp][1][_p1var] = dseff_qp; _dgrads_qp_dv[_qp][1][_p1var] = d2seff_qp * (_phase0_gradp_qp[_qp] - _phase1_gradp_qp[_qp]); } }
void PorousFlowTemperature::computeQpProperties() { _temperature[_qp] = _temperature_var[_qp]; _dtemperature_dvar[_qp].assign(_num_pf_vars, 0.0); if (_temperature_is_PF) // _temperature is a PorousFlow variable _dtemperature_dvar[_qp][_t_var_num] = 1.0; if (!_nodal_material) { (*_grad_temperature)[_qp] = (*_grad_temperature_var)[_qp]; (*_dgrad_temperature_dgradv)[_qp].assign(_num_pf_vars, 0.0); (*_dgrad_temperature_dv)[_qp].assign(_num_pf_vars, RealGradient()); if (_temperature_is_PF) (*_dgrad_temperature_dgradv)[_qp][_t_var_num] = 1.0; } }
RealGradient KernelGrad::precomputeQpJacobian() { return RealGradient(0.0); }
RealGradient FE<2,NEDELEC_ONE>::shape(const Elem* elem, const Order order, const unsigned int i, const Point& p) { #if LIBMESH_DIM > 1 libmesh_assert(elem); const Order total_order = static_cast<Order>(order + elem->p_level()); switch (total_order) { case FIRST: { switch (elem->type()) { case QUAD8: case QUAD9: { libmesh_assert_less (i, 4); const Real xi = p(0); const Real eta = p(1); // Even with a loose inverse_map tolerance we ought to // be nearly on the element interior in master // coordinates libmesh_assert_less_equal ( std::fabs(xi), 1.0+10*TOLERANCE ); libmesh_assert_less_equal ( std::fabs(eta), 1.0+10*TOLERANCE ); switch(i) { case 0: { if( elem->point(0) > elem->point(1) ) return RealGradient( -0.25*(1.0-eta), 0.0 ); else return RealGradient( 0.25*(1.0-eta), 0.0 ); } case 1: { if( elem->point(1) > elem->point(2) ) return RealGradient( 0.0, -0.25*(1.0+xi) ); else return RealGradient( 0.0, 0.25*(1.0+xi) ); } case 2: { if( elem->point(2) > elem->point(3) ) return RealGradient( 0.25*(1.0+eta), 0.0 ); else return RealGradient( -0.25*(1.0+eta), 0.0 ); } case 3: { if( elem->point(3) > elem->point(0) ) return RealGradient( 0.0, -0.25*(xi-1.0) ); else return RealGradient( 0.0, 0.25*(xi-1.0) ); } default: libmesh_error(); } return RealGradient(); } case TRI6: { const Real xi = p(0); const Real eta = p(1); libmesh_assert_less (i, 3); switch(i) { case 0: { if( elem->point(0) > elem->point(1) ) return RealGradient( -1.0+eta, -xi ); else return RealGradient( 1.0-eta, xi ); } case 1: { if( elem->point(1) > elem->point(2) ) return RealGradient( eta, -xi ); else return RealGradient( -eta, xi ); } case 2: { if( elem->point(2) > elem->point(0) ) return RealGradient( eta, -xi+1.0 ); else return RealGradient( -eta, xi-1.0 ); } default: libmesh_error(); } } default: { libMesh::err << "ERROR: Unsupported 2D element type!: " << elem->type() << std::endl; libmesh_error(); } } } // unsupported order default: { libMesh::err << "ERROR: Unsupported 2D FE order!: " << total_order << std::endl; libmesh_error(); } } #endif // LIBMESH_DIM > 1 libmesh_error(); return RealGradient(); }
RealGradient FE<2,NEDELEC_ONE>::shape_deriv(const Elem* elem, const Order order, const unsigned int i, const unsigned int j, const Point&) { #if LIBMESH_DIM > 1 libmesh_assert(elem); libmesh_assert_less (j, 2); const Order total_order = static_cast<Order>(order + elem->p_level()); switch (total_order) { // linear Lagrange shape functions case FIRST: { switch (elem->type()) { case QUAD8: case QUAD9: { libmesh_assert_less (i, 4); switch (j) { // d()/dxi case 0: { switch(i) { case 0: case 2: return RealGradient(); case 1: { if( elem->point(1) > elem->point(2) ) return RealGradient( 0.0, -0.25 ); else return RealGradient( 0.0, 0.25 ); } case 3: { if( elem->point(3) > elem->point(0) ) return RealGradient( 0.0, -0.25 ); else return RealGradient( 0.0, 0.25 ); } default: libmesh_error(); } } // j=0 // d()/deta case 1: { switch(i) { case 1: case 3: return RealGradient(); case 0: { if( elem->point(0) > elem->point(1) ) return RealGradient( 0.25 ); else return RealGradient( -0.25 ); } case 2: { if( elem->point(2) > elem->point(3) ) return RealGradient( 0.25 ); else return RealGradient( -0.25 ); } default: libmesh_error(); } } // j=1 default: libmesh_error(); } return RealGradient(); } case TRI6: { libmesh_assert_less (i, 3); // Account for edge flipping Real f = 1.0; switch(i) { case 0: { if( elem->point(0) > elem->point(1) ) f = -1.0; break; } case 1: { if( elem->point(1) > elem->point(2) ) f = -1.0; break; } case 2: { if( elem->point(2) > elem->point(0) ) f = -1.0; break; } default: libmesh_error(); } switch (j) { // d()/dxi case 0: { return RealGradient( 0.0, f*1.0); } // d()/deta case 1: { return RealGradient( f*(-1.0) ); } default: libmesh_error(); } } default: { libMesh::err << "ERROR: Unsupported 2D element type!: " << elem->type() << std::endl; libmesh_error(); } } } // unsupported order default: { libMesh::err << "ERROR: Unsupported 2D FE order!: " << total_order << std::endl; libmesh_error(); } } #endif // LIBMESH_DIM > 1 libmesh_error(); return RealGradient(); }
RealGradient Function::gradient(Real /*t*/, const Point & /*p*/) { return RealGradient(0, 0, 0); }
std::vector<RealGradient> CNSFVWENOSlopeLimiting::limitElementSlope() const { const Elem * elem = _current_elem; /// current element id dof_id_type _elementID = elem->id(); /// number of conserved variables unsigned int nvars = 5; /// number of sides surrounding an element unsigned int nside = elem->n_sides(); /// vector for the limited gradients of the conserved variables std::vector<RealGradient> ugrad(nvars, RealGradient(0., 0., 0.)); /// initialize local cache for reconstructed element gradients std::vector<RealGradient> rugrad(nvars, RealGradient(0., 0., 0.)); /// a small number to avoid dividing by zero Real eps = 1e-7; /// initialize oscillation indicator std::vector<std::vector<Real>> osci(nside + 1, std::vector<Real>(nvars, 0.)); /// initialize weight coefficients std::vector<std::vector<Real>> weig(nside + 1, std::vector<Real>(nvars, 0.)); /// initialize summed coefficients std::vector<Real> summ(nvars, 0.); /// compute oscillation indicators, nonlinear weights and their summ for each stencil rugrad = _rslope.getElementSlope(_elementID); for (unsigned int iv = 0; iv < nvars; iv++) { osci[0][iv] = std::sqrt(rugrad[iv] * rugrad[iv]); weig[0][iv] = _lweig / std::pow(eps + osci[0][iv], _dpowe); summ[iv] = weig[0][iv]; } for (unsigned int is = 0; is < nside; is++) { unsigned int in = is + 1; if (elem->neighbor(is) != NULL) { dof_id_type _neighborID = elem->neighbor(is)->id(); rugrad = _rslope.getElementSlope(_neighborID); for (unsigned int iv = 0; iv < nvars; iv++) { osci[in][iv] = std::sqrt(rugrad[iv] * rugrad[iv]); weig[in][iv] = 1. / std::pow(eps + osci[in][iv], _dpowe); summ[iv] += weig[in][iv]; } } } /// compute the normalized weight for (unsigned int iv = 0; iv < nvars; iv++) weig[0][iv] = weig[0][iv] / summ[iv]; for (unsigned int is = 0; is < nside; is++) { unsigned int in = is + 1; if (elem->neighbor(is) != NULL) for (unsigned int iv = 0; iv < nvars; iv++) weig[in][iv] = weig[in][iv] / summ[iv]; } /// compute the limited slope rugrad = _rslope.getElementSlope(_elementID); for (unsigned int iv = 0; iv < nvars; iv++) ugrad[iv] = weig[0][iv] * rugrad[iv]; for (unsigned int is = 0; is < nside; is++) { unsigned int in = is + 1; if (elem->neighbor(is) != NULL) { dof_id_type _neighborID = elem->neighbor(is)->id(); rugrad = _rslope.getElementSlope(_neighborID); for (unsigned int iv = 0; iv < nvars; iv++) ugrad[iv] += weig[in][iv] * rugrad[iv]; } } return ugrad; }
std::vector<RealGradient> CNSFVMinmaxSlopeLimiting::limitElementSlope() const { const Elem * elem = _current_elem; /// current element id dof_id_type _elementID = elem->id(); /// current element centroid coordinte Point ecent = elem->centroid(); /// number of sides surrounding an element unsigned int nside = elem->n_sides(); /// number of conserved variables unsigned int nvars = 5; /// vector for the centroid of the sides surrounding an element std::vector<Point> scent(nside, Point(0., 0., 0.)); /// vector for the limited gradients of the conserved variables std::vector<RealGradient> ugrad(nvars, RealGradient(0., 0., 0.)); /// a flag to indicate the boundary side of the current cell bool bflag = false; /// initialize local minimum variable values std::vector<Real> umin(nvars, 0.); /// initialize local maximum variable values std::vector<Real> umax(nvars, 0.); /// initialize local cache for element variable values std::vector<Real> uelem(nvars, 0.); /// initialize local cache for reconstructed element gradients std::vector<RealGradient> rugrad(nvars, RealGradient(0., 0., 0.)); /// initialize local cache for element slope limitor values std::vector<std::vector<Real>> limit(nside + 1, std::vector<Real>(nvars, 1.)); Real dij = 0.; uelem = _rslope.getElementAverageValue(_elementID); for (unsigned int iv = 0; iv < nvars; iv++) { umin[iv] = uelem[iv]; umax[iv] = uelem[iv]; } /// loop over the sides to find the min and max cell-average values for (unsigned int is = 0; is < nside; is++) { const Elem * neighbor = elem->neighbor_ptr(is); if (neighbor != nullptr && this->hasBlocks(neighbor->subdomain_id())) { dof_id_type _neighborID = neighbor->id(); uelem = _rslope.getElementAverageValue(_neighborID); scent[is] = _rslope.getSideCentroid(_elementID, _neighborID); } else { uelem = _rslope.getBoundaryAverageValue(_elementID, is); scent[is] = _rslope.getBoundarySideCentroid(_elementID, is); } for (unsigned int iv = 0; iv < nvars; iv++) { if (uelem[iv] < umin[iv]) umin[iv] = uelem[iv]; if (uelem[iv] > umax[iv]) umax[iv] = uelem[iv]; } } /// loop over the sides to compute the limiter values rugrad = _rslope.getElementSlope(_elementID); uelem = _rslope.getElementAverageValue(_elementID); for (unsigned int is = 0; is < nside; is++) { for (unsigned int iv = 0; iv < nvars; iv++) { dij = (scent[is] - ecent) * rugrad[iv]; if (dij > 0.) limit[is + 1][iv] = std::min(1., (umax[iv] - uelem[iv]) / dij); else if (dij < 0.) limit[is + 1][iv] = std::min(1., (umin[iv] - uelem[iv]) / dij); } } /// loop over the sides to get the final limiter of this cell for (unsigned int is = 0; is < nside; is++) { for (unsigned int iv = 0; iv < nvars; iv++) { if (limit[0][iv] > limit[is + 1][iv]) limit[0][iv] = limit[is + 1][iv]; } } /// get the limited slope of this cell if (!_include_bc && bflag) { for (unsigned int iv = 0; iv < nvars; iv++) ugrad[iv] = RealGradient(0., 0., 0.); } else { for (unsigned int iv = 0; iv < nvars; iv++) ugrad[iv] = rugrad[iv] * limit[0][iv]; } return ugrad; }
RealGradient FE<3,NEDELEC_ONE>::shape(const Elem * elem, const Order order, const unsigned int i, const Point & p) { #if LIBMESH_DIM == 3 libmesh_assert(elem); const Order totalorder = static_cast<Order>(order + elem->p_level()); switch (totalorder) { // linear Lagrange shape functions case FIRST: { switch (elem->type()) { case HEX20: case HEX27: { libmesh_assert_less (i, 12); const Real xi = p(0); const Real eta = p(1); const Real zeta = p(2); // Even with a loose inverse_map tolerance we ought to // be nearly on the element interior in master // coordinates libmesh_assert_less_equal ( std::fabs(xi), 1.0+10*TOLERANCE ); libmesh_assert_less_equal ( std::fabs(eta), 1.0+10*TOLERANCE ); libmesh_assert_less_equal ( std::fabs(zeta), 1.0+10*TOLERANCE ); switch(i) { case 0: { if( elem->point(0) > elem->point(1) ) return RealGradient( -0.125*(1.0-eta-zeta+eta*zeta), 0.0, 0.0 ); else return RealGradient( 0.125*(1.0-eta-zeta+eta*zeta), 0.0, 0.0 ); } case 1: { if( elem->point(1) > elem->point(2) ) return RealGradient( 0.0, -0.125*(1.0+xi-zeta-xi*zeta), 0.0 ); else return RealGradient( 0.0, 0.125*(1.0+xi-zeta-xi*zeta), 0.0 ); } case 2: { if( elem->point(2) > elem->point(3) ) return RealGradient( 0.125*(1.0+eta-zeta-eta*zeta), 0.0, 0.0 ); else return RealGradient( -0.125*(1.0+eta-zeta-eta*zeta), 0.0, 0.0 ); } case 3: { if( elem->point(3) > elem->point(0) ) return RealGradient( 0.0, 0.125*(1.0-xi-zeta+xi*zeta), 0.0 ); else return RealGradient( 0.0, -0.125*(1.0-xi-zeta+xi*zeta), 0.0 ); } case 4: { if( elem->point(0) > elem->point(4) ) return RealGradient( 0.0, 0.0, -0.125*(1.0-xi-eta+xi*eta) ); else return RealGradient( 0.0, 0.0, 0.125*(1.0-xi-eta+xi*eta) ); } case 5: { if( elem->point(1) > elem->point(5) ) return RealGradient( 0.0, 0.0, -0.125*(1.0+xi-eta-xi*eta) ); else return RealGradient( 0.0, 0.0, 0.125*(1.0+xi-eta-xi*eta) ); } case 6: { if( elem->point(2) > elem->point(6) ) return RealGradient( 0.0, 0.0, -0.125*(1.0+xi+eta+xi*eta) ); else return RealGradient( 0.0, 0.0, 0.125*(1.0+xi+eta+xi*eta) ); } case 7: { if( elem->point(3) > elem->point(7) ) return RealGradient( 0.0, 0.0, -0.125*(1.0-xi+eta-xi*eta) ); else return RealGradient( 0.0, 0.0, 0.125*(1.0-xi+eta-xi*eta) ); } case 8: { if( elem->point(4) > elem->point(5) ) return RealGradient( -0.125*(1.0-eta+zeta-eta*zeta), 0.0, 0.0 ); else return RealGradient( 0.125*(1.0-eta+zeta-eta*zeta), 0.0, 0.0 ); } case 9: { if( elem->point(5) > elem->point(6) ) return RealGradient( 0.0, -0.125*(1.0+xi+zeta+xi*zeta), 0.0 ); else return RealGradient( 0.0, 0.125*(1.0+xi+zeta+xi*zeta), 0.0 ); } case 10: { if( elem->point(7) > elem->point(6) ) return RealGradient( -0.125*(1.0+eta+zeta+eta*zeta), 0.0, 0.0 ); else return RealGradient( 0.125*(1.0+eta+zeta+eta*zeta), 0.0, 0.0 ); } case 11: { if( elem->point(4) > elem->point(7) ) return RealGradient( 0.0, -0.125*(1.0-xi+zeta-xi*zeta), 0.0 ); else return RealGradient( 0.0, 0.125*(1.0-xi+zeta-xi*zeta), 0.0 ); } default: libmesh_error_msg("Invalid i = " << i); } return RealGradient(); } case TET10: { libmesh_assert_less (i, 6); libmesh_not_implemented(); return RealGradient(); } default: libmesh_error_msg("ERROR: Unsupported 3D element type!: " << elem->type()); } } // unsupported order default: libmesh_error_msg("ERROR: Unsupported 3D FE order!: " << totalorder); } #endif libmesh_error_msg("We'll never get here!"); return RealGradient(); }
RealGradient FE<3,NEDELEC_ONE>::shape_second_deriv(const Elem * elem, const Order order, const unsigned int i, const unsigned int j, const Point & libmesh_dbg_var(p)) { #if LIBMESH_DIM == 3 libmesh_assert(elem); // j = 0 ==> d^2 phi / dxi^2 // j = 1 ==> d^2 phi / dxi deta // j = 2 ==> d^2 phi / deta^2 // j = 3 ==> d^2 phi / dxi dzeta // j = 4 ==> d^2 phi / deta dzeta // j = 5 ==> d^2 phi / dzeta^2 libmesh_assert_less (j, 6); const Order totalorder = static_cast<Order>(order + elem->p_level()); switch (totalorder) { // linear Lagrange shape functions case FIRST: { switch (elem->type()) { case HEX20: case HEX27: { libmesh_assert_less (i, 12); #ifndef NDEBUG const Real xi = p(0); const Real eta = p(1); const Real zeta = p(2); #endif libmesh_assert_less_equal ( std::fabs(xi), 1.0+TOLERANCE ); libmesh_assert_less_equal ( std::fabs(eta), 1.0+TOLERANCE ); libmesh_assert_less_equal ( std::fabs(zeta), 1.0+TOLERANCE ); switch (j) { // d^2()/dxi^2 case 0: { // All d^2()/dxi^2 derivatives for linear hexes are zero. return RealGradient(); } // j=0 // d^2()/dxideta case 1: { switch(i) { case 0: case 1: case 2: case 3: case 8: case 9: case 10: case 11: return RealGradient(); case 4: { if( elem->point(0) > elem->point(4) ) return RealGradient( 0.0, 0.0, -0.125 ); else return RealGradient( 0.0, 0.0, 0.125 ); } case 5: { if( elem->point(1) > elem->point(5) ) return RealGradient( 0.0, 0.0, 0.125 ); else return RealGradient( 0.0, 0.0, -0.125 ); } case 6: { if( elem->point(2) > elem->point(6) ) return RealGradient( 0.0, 0.0, -0.125 ); else return RealGradient( 0.0, 0.0, 0.125 ); } case 7: { if( elem->point(3) > elem->point(7) ) return RealGradient( 0.0, 0.0, 0.125 ); else return RealGradient( 0.0, 0.0, -0.125 ); } default: libmesh_error_msg("Invalid i = " << i); } // switch(i) } // j=1 // d^2()/deta^2 case 2: { // All d^2()/deta^2 derivatives for linear hexes are zero. return RealGradient(); } // j = 2 // d^2()/dxidzeta case 3: { switch(i) { case 0: case 2: case 4: case 5: case 6: case 7: case 8: case 10: return RealGradient(); case 1: { if( elem->point(1) > elem->point(2) ) return RealGradient( 0.0, 0.125 ); else return RealGradient( 0.0, -0.125 ); } case 3: { if( elem->point(3) > elem->point(0) ) return RealGradient( 0.0, -0.125 ); else return RealGradient( 0.0, 0.125 ); } case 9: { if( elem->point(5) > elem->point(6) ) return RealGradient( 0.0, -0.125, 0.0 ); else return RealGradient( 0.0, 0.125, 0.0 ); } case 11: { if( elem->point(4) > elem->point(7) ) return RealGradient( 0.0, 0.125, 0.0 ); else return RealGradient( 0.0, -0.125, 0.0 ); } default: libmesh_error_msg("Invalid i = " << i); } // switch(i) } // j = 3 // d^2()/detadzeta case 4: { switch(i) { case 1: case 3: case 4: case 5: case 6: case 7: case 9: case 11: return RealGradient(); case 0: { if( elem->point(0) > elem->point(1) ) return RealGradient( -0.125, 0.0, 0.0 ); else return RealGradient( 0.125, 0.0, 0.0 ); } case 2: { if( elem->point(2) > elem->point(3) ) return RealGradient( 0.125, 0.0, 0.0 ); else return RealGradient( -0.125, 0.0, 0.0 ); } case 8: { if( elem->point(4) > elem->point(5) ) return RealGradient( 0.125, 0.0, 0.0 ); else return RealGradient( -0.125, 0.0, 0.0 ); } case 10: { if( elem->point(7) > elem->point(6) ) return RealGradient( -0.125, 0.0, 0.0 ); else return RealGradient( 0.125, 0.0, 0.0 ); } default: libmesh_error_msg("Invalid i = " << i); } // switch(i) } // j = 4 // d^2()/dzeta^2 case 5: { // All d^2()/dzeta^2 derivatives for linear hexes are zero. return RealGradient(); } // j = 5 default: libmesh_error_msg("Invalid j = " << j); } return RealGradient(); } case TET10: { libmesh_assert_less (i, 6); libmesh_not_implemented(); return RealGradient(); } default: libmesh_error_msg("ERROR: Unsupported 3D element type!: " << elem->type()); } //switch(type) } // case FIRST: // unsupported order default: libmesh_error_msg("ERROR: Unsupported 3D FE order!: " << totalorder); } #endif libmesh_error_msg("We'll never get here!"); return RealGradient(); }
InputParameters validParams<PTGeothermal>() { InputParameters params = validParams<Material>(); MooseEnum stat("constant compressibility wseos", "constant"); params.addParam<MooseEnum>("fluid_property_formulation", stat, "Fluid property formulation, default = constant"); MooseEnum stabilizer("none zero supg supg_dc", "none"); params.addParam<MooseEnum>("stabilizer", stabilizer, "Energy transport stabilizer, default = none"); params.addParam<bool>( "pressure_dependent_permeability", false, "Flag true if permeability is pressure dependent, default = false"); params.addParam<Real>( "reference_pressure", 101325, "Reference pressure [Pa], default = 101325"); params.addParam<Real>( "reference_temperature", 297.15, "Reference temperature [K], default = 297.15"); params.addParam<Real>( "permeability", 1.0e-12, "Intrinsic permeability [m^2], default = 1.0e-12"); params.addParam<Real>( "porosity", 0.3, "Rock porosity, default = 0.3"); params.addParam<Real>( "compressibility", 1.0e-5, "Total compressibility of the researvoir, default = 1.0e-5"); params.addParam<Real>( "density_rock", 2.50e3, "Rock density [kg/m^3]"); params.addParam<Real>( "gravity", 9.80665, "Gravity acceleration constant [m/s^2], default = 9.80665"); params.addParam<RealGradient>( "gravity_direction", RealGradient(0,0,-1), "Gravity unit directional vector, default = '0 0 -1'"); params.addParam<RealGradient>( "constant_pressure_gradient", RealGradient(0,0,0), "Constant pressure gradient, default = '0 0 0'"); params.addCoupledVar( "pressure", "Assign nonlinear variable for pressure [Pa], if mass balance is involved"); params.addCoupledVar( "temperature", "Assign nonlinear variable for temperature [K], if energy balance is involved"); params.addParam<Real>( "density_water", 1000, "Initial water density [kg/m^3], default = 1000"); params.addParam<Real>( "viscosity_water", 0.001, "Initial water viscosity [Pa.s], default = 0.001"); params.addParam<Real>( "specific_heat_rock", 0.92e3, "Specific heat of the rock [J/(kg.K)], default = 0.92e3"); params.addParam<Real>( "specific_heat_water", 4.186e3, "Specific heat of water [J/(kg.K)], default = 4.186e3"); params.addParam<Real>( "thermal_conductivity", 2.5, "Thermal conductivity of the reservoir [W/(m.K)], default = 2.5"); params.addParam<Real>( "supg_dc_threshold", 1e-12, "Threshold magnitude of temperature gradient to include SUPG discontinuity capturing, default = 1e-12"); return params; }