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