void
PorousFlow1PhaseP::computeQpProperties()
{
  // size stuff correctly and prepare the derivative matrices with zeroes
  PorousFlowVariableBase::computeQpProperties();

  buildQpPPSS();
  const Real dseff = dEffectiveSaturation_dP(_porepressure_var[_qp]);

  if (!_nodal_material)
  {
    (*_gradp_qp)[_qp][0] = _gradp_qp_var[_qp];
    (*_grads_qp)[_qp][0] = dseff * _gradp_qp_var[_qp];
  }

  // _porepressure is only dependent on _porepressure, and its derivative is 1
  if (_dictator.isPorousFlowVariable(_porepressure_varnum))
  {
    // _porepressure is a PorousFlow variable
    _dporepressure_dvar[_qp][0][_p_var_num] = 1.0;
    _dsaturation_dvar[_qp][0][_p_var_num] = dseff;
    if (!_nodal_material)
    {
      (*_dgradp_qp_dgradv)[_qp][0][_p_var_num] = 1.0;
      (*_dgrads_qp_dgradv)[_qp][0][_p_var_num] = dseff;
      (*_dgrads_qp_dv)[_qp][0][_p_var_num] =
          d2EffectiveSaturation_dP2(_porepressure_var[_qp]) * _gradp_qp_var[_qp];
    }
  }
}
Example #2
0
void
PorousFlow2PhasePP::buildQpPPSS()
{
  _porepressure_nodal[_qp][0] = _phase0_porepressure_nodal[_qp];
  _porepressure_nodal[_qp][1] = _phase1_porepressure_nodal[_qp];
  _porepressure_qp[_qp][0] = _phase0_porepressure_qp[_qp];
  _porepressure_qp[_qp][1] = _phase1_porepressure_qp[_qp];
  _gradp_qp[_qp][0] = _phase0_gradp_qp[_qp];
  _gradp_qp[_qp][1] = _phase1_gradp_qp[_qp];

  const Real pc_nodal = _phase0_porepressure_nodal[_qp] - _phase1_porepressure_nodal[_qp]; // this is <= 0
  const Real seff_nodal = effectiveSaturation(pc_nodal);

  const Real pc_qp = _phase0_porepressure_qp[_qp] - _phase1_porepressure_qp[_qp]; // this is <= 0
  const Real seff_qp = effectiveSaturation(pc_qp);
  const Real dseff_qp = dEffectiveSaturation_dP(pc_qp); // d(seff_qp)/d(pc_qp)

  _saturation_nodal[_qp][0] = seff_nodal;
  _saturation_nodal[_qp][1] = 1.0 - seff_nodal;
  _saturation_qp[_qp][0] = seff_qp;
  _saturation_qp[_qp][1] = 1.0 - seff_qp;
  _grads_qp[_qp][0] = dseff_qp * (_gradp_qp[_qp][0] - _gradp_qp[_qp][1]);
  _grads_qp[_qp][1] = - _grads_qp[_qp][0];

  /// Temperature is the same in each phase presently
  _temperature_nodal[_qp][0] = _temperature_nodal_var[_qp];
  _temperature_nodal[_qp][1] = _temperature_nodal_var[_qp];
  _temperature_qp[_qp][0] = _temperature_qp_var[_qp];
  _temperature_qp[_qp][1] = _temperature_qp_var[_qp];
}
Example #3
0
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
PorousFlow2PhasePP::computeQpProperties()
{
  // size stuff correctly and prepare the derivative matrices with zeroes
  PorousFlowVariableBase::computeQpProperties();

  const Real pc = buildQpPPSS();
  const Real dseff = dEffectiveSaturation_dP(pc); // d(seff)/d(pc)

  if (!_nodal_material)
  {
    (*_gradp_qp)[_qp][0] = _phase0_gradp_qp[_qp];
    (*_gradp_qp)[_qp][1] = _phase1_gradp_qp[_qp];
    (*_grads_qp)[_qp][0] = dseff * ((*_gradp_qp)[_qp][0] - (*_gradp_qp)[_qp][1]);
    (*_grads_qp)[_qp][1] = -(*_grads_qp)[_qp][0];
  }

  // the derivatives of porepressure with respect to porepressure
  // remain fixed (at unity) throughout the simulation
  if (_dictator.isPorousFlowVariable(_phase0_porepressure_varnum))
  {
    _dporepressure_dvar[_qp][0][_p0var] = 1.0;
    if (!_nodal_material)
      (*_dgradp_qp_dgradv)[_qp][0][_p0var] = 1.0;
  }
  if (_dictator.isPorousFlowVariable(_phase1_porepressure_varnum))
  {
    _dporepressure_dvar[_qp][1][_p1var] = 1.0;
    if (!_nodal_material)
      (*_dgradp_qp_dgradv)[_qp][1][_p1var] = 1.0;
  }

  if (_dictator.isPorousFlowVariable(_phase0_porepressure_varnum))
  {
    _dsaturation_dvar[_qp][0][_p0var] = dseff;
    _dsaturation_dvar[_qp][1][_p0var] = -dseff;
  }
  if (_dictator.isPorousFlowVariable(_phase1_porepressure_varnum))
  {
    _dsaturation_dvar[_qp][0][_p1var] = -dseff;
    _dsaturation_dvar[_qp][1][_p1var] = dseff;
  }

  if (!_nodal_material)
  {
    const Real d2seff_qp = d2EffectiveSaturation_dP2(pc); // d^2(seff_qp)/d(pc_qp)^2
    if (_dictator.isPorousFlowVariable(_phase0_porepressure_varnum))
    {
      (*_dgrads_qp_dgradv)[_qp][0][_p0var] = dseff;
      (*_dgrads_qp_dv)[_qp][0][_p0var] =
          d2seff_qp * (_phase0_gradp_qp[_qp] - _phase1_gradp_qp[_qp]);
      (*_dgrads_qp_dgradv)[_qp][1][_p0var] = -dseff;
      (*_dgrads_qp_dv)[_qp][1][_p0var] =
          -d2seff_qp * (_phase0_gradp_qp[_qp] - _phase1_gradp_qp[_qp]);
    }
    if (_dictator.isPorousFlowVariable(_phase1_porepressure_varnum))
    {
      (*_dgrads_qp_dgradv)[_qp][0][_p1var] = -dseff;
      (*_dgrads_qp_dv)[_qp][0][_p1var] =
          -d2seff_qp * (_phase0_gradp_qp[_qp] - _phase1_gradp_qp[_qp]);
      (*_dgrads_qp_dgradv)[_qp][1][_p1var] = dseff;
      (*_dgrads_qp_dv)[_qp][1][_p1var] =
          d2seff_qp * (_phase0_gradp_qp[_qp] - _phase1_gradp_qp[_qp]);
    }
  }
}