Q2PBorehole Class Reference

Approximates a borehole by a sequence of Dirac Points. More...

#include <Q2PBorehole.h>

Inheritance diagram for Q2PBorehole:

Public Member Functions
	Q2PBorehole (const InputParameters &parameters)
	Creates a new Q2PBorehole This sets all the variables, but also reads the file containing the lines of the form radius x y z that defines the borehole geometry. More...
virtual void	computeResidual ()
	Computes the residual. More...
virtual Real	computeQpResidual ()
	Computes the Qp residual. More...
virtual void	computeJacobian ()
	Computes the Jacobian. More...
virtual Real	computeQpJacobian ()
	Computes the diagonal part of the jacobian. More...
virtual Real	computeQpOffDiagJacobian (unsigned int jvar)
	Computes the off-diagonal part of the jacobian. More...

Protected Member Functions
void	prepareNodalValues ()
	calculates the nodal values of pressure, mobility, and derivatives thereof More...
Real	jac (unsigned int jvar)
	Calculates Jacobian. More...
virtual void	addPoints ()
	Add Dirac Points to the borehole. More...
bool	parseNextLineReals (std::ifstream &ifs, std::vector< Real > &myvec)
	reads a space-separated line of floats from ifs and puts in myvec More...
Real	wellConstant (const RealTensorValue &perm, const RealTensorValue &rot, const Real &half_len, const Elem *ele, const Real &rad)
	Calculates Peaceman's form of the borehole well constant Z Chen, Y Zhang, Well flow models for various numerical methods, Int J Num Analysis and Modeling, 3 (2008) 375-388. More...

Protected Attributes
const RichardsDensity &	_density
	fluid density More...
const RichardsRelPerm &	_relperm
	fluid relative permeability More...
const VariableValue &	_other_var_nodal
	the other variable in the 2-phase system (this is saturation if Variable=porepressure, and viceversa) More...
const unsigned int	_other_var_num
	the variable number of the other variable More...
const bool	_var_is_pp
	whether the Variable for this BC is porepressure or not More...
const Real	_viscosity
	viscosity More...
const MaterialProperty< RealTensorValue > &	_permeability
	permeability More...
unsigned int	_num_nodes
	number of nodes in this element. More...
std::vector< Real >	_pp
	nodal porepressure More...
std::vector< Real >	_sat
	nodal saturation More...
std::vector< Real >	_mobility
	nodal mobility More...
std::vector< Real >	_dmobility_dp
	nodal d(mobility)/d(porepressure) More...
std::vector< Real >	_dmobility_ds
	nodal d(mobility)/d(saturation) More...
Function &	_character
	If positive then the borehole acts as a sink (producion well) for porepressure > borehole pressure, and does nothing otherwise If negative then the borehole acts as a source (injection well) for porepressure < borehole pressure, and does nothing otherwise The flow rate to/from the borehole is multiplied by |character|, so usually character = +/- 1. More...
const Real	_p_bot
	bottomhole pressure of borehole More...
const RealVectorValue	_unit_weight
	unit weight of fluid in borehole (for calculating bottomhole pressure at each Dirac Point) More...
RichardsSumQuantity &	_total_outflow_mass
	This is used to hold the total fluid flowing into the borehole Hence, it is positive for production wells where fluid is flowing from porespace into the borehole and removed from the model. More...
std::vector< Real >	_rs
	radii of the borehole More...
std::vector< Real >	_xs
	x points of the borehole More...
std::vector< Real >	_ys
	y points of the borehole More...
std::vector< Real >	_zs
	z points of borehole More...
Point	_bottom_point
	the bottom point of the borehole (where bottom_pressure is defined) More...
std::vector< Real >	_half_seg_len
	0.5*(length of polyline segments between points) More...
std::vector< RealTensorValue >	_rot_matrix
	rotation matrix used in well_constant calculation More...

Detailed Description

Approximates a borehole by a sequence of Dirac Points.

This is for use by a Q2P model.

Definition at line 27 of file Q2PBorehole.h.

Constructor & Destructor Documentation

Q2PBorehole()

Q2PBorehole::Q2PBorehole

(

const InputParameters &

parameters

)

Creates a new Q2PBorehole This sets all the variables, but also reads the file containing the lines of the form radius x y z that defines the borehole geometry.

It also calculates segment-lengths and rotation matrices needed for computing the borehole well constant

Definition at line 44 of file Q2PBorehole.C.

  : PeacemanBorehole(parameters),
    _density(getUserObject<RichardsDensity>("fluid_density")),
    _relperm(getUserObject<RichardsRelPerm>("fluid_relperm")),
    _other_var_nodal(coupledDofValues("other_var")),
    _other_var_num(coupled("other_var")),
    _var_is_pp(getParam<bool>("var_is_porepressure")),
    _viscosity(getParam<Real>("fluid_viscosity")),
    _permeability(getMaterialProperty<RealTensorValue>("permeability")),
    _num_nodes(0),
    _pp(0),
    _sat(0),
    _mobility(0),
    _dmobility_dp(0),
    _dmobility_ds(0)
{
}

Member Function Documentation

addPoints()

void PeacemanBorehole::addPoints ( )

protectedvirtualinherited

Add Dirac Points to the borehole.

Definition at line 180 of file PeacemanBorehole.C.

{
  // This function gets called just before the DiracKernel is evaluated
  // so this is a handy place to zero this out.
  _total_outflow_mass.zero();

  // Add point using the unique ID "i", let the DiracKernel take
  // care of the caching.  This should be fast after the first call,
  // as long as the points don't move around.
  for (unsigned int i = 0; i < _zs.size(); i++)
    addPoint(Point(_xs[i], _ys[i], _zs[i]), i);
}

computeJacobian()

void Q2PBorehole::computeJacobian ( )

virtual

Computes the Jacobian.

This just calls prepareNodalValues then calls DiracKernel::computeJacobian

Definition at line 171 of file Q2PBorehole.C.

{
  prepareNodalValues();
  DiracKernel::computeJacobian();
}

computeQpJacobian()

Real Q2PBorehole::computeQpJacobian ( )

virtual

Computes the diagonal part of the jacobian.

Definition at line 178 of file Q2PBorehole.C.

{
  return jac(_var.number());
}

computeQpOffDiagJacobian()

Real Q2PBorehole::computeQpOffDiagJacobian ( unsigned int  jvar )

virtual

Computes the off-diagonal part of the jacobian.

Definition at line 184 of file Q2PBorehole.C.

{
  if (jvar == _other_var_num || jvar == _var.number())
    return jac(jvar);
  return 0.0;
}

computeQpResidual()

Real Q2PBorehole::computeQpResidual ( )

virtual

Computes the Qp residual.

Definition at line 114 of file Q2PBorehole.C.

{
  const Real character = _character.value(_t, _q_point[_qp]);
  if (character == 0.0)
    return 0.0;

  const Real bh_pressure =
      _p_bot +
      _unit_weight *
          (_q_point[_qp] -
           _bottom_point); // really want to use _q_point instaed of _current_point, i think?!

  // Get the ID we initially assigned to this point
  const unsigned current_dirac_ptid = currentPointCachedID();

  // If getting the ID failed, fall back to the old bodge!
  // if (current_dirac_ptid == libMesh::invalid_uint)
  //  current_dirac_ptid = (_zs.size() > 2) ? 1 : 0;

  Real outflow(0.0); // this is the flow rate from porespace out of the system

  Real wc(0.0);
  if (current_dirac_ptid > 0)
  // contribution from half-segment "behind" this point (must have >1 point for
  // current_dirac_ptid>0)
  {
    wc = wellConstant(_permeability[0],
                      _rot_matrix[current_dirac_ptid - 1],
                      _half_seg_len[current_dirac_ptid - 1],
                      _current_elem,
                      _rs[current_dirac_ptid]);
    if ((character < 0.0 && _pp[_i] < bh_pressure) || (character > 0.0 && _pp[_i] > bh_pressure))
      // injection, so outflow<0 || // production, so outflow>0
      outflow +=
          _test[_i][_qp] * std::abs(character) * wc * _mobility[_i] * (_pp[_i] - bh_pressure);
  }

  if (current_dirac_ptid + 1 < _zs.size() || _zs.size() == 1)
  // contribution from half-segment "ahead of" this point, or we only have one point
  {
    wc = wellConstant(_permeability[0],
                      _rot_matrix[current_dirac_ptid],
                      _half_seg_len[current_dirac_ptid],
                      _current_elem,
                      _rs[current_dirac_ptid]);
    if ((character < 0.0 && _pp[_i] < bh_pressure) || (character > 0.0 && _pp[_i] > bh_pressure))
      // injection, so outflow<0 || // production, so outflow>0
      outflow +=
          _test[_i][_qp] * std::abs(character) * wc * _mobility[_i] * (_pp[_i] - bh_pressure);
  }

  _total_outflow_mass.add(
      outflow * _dt); // this is not thread safe, but DiracKernel's aren't currently threaded
  return outflow;
}

computeResidual()

void Q2PBorehole::computeResidual ( )

virtual

Computes the residual.

This just calls prepareNodalValues then calls DiracKernel::computeResidual

Definition at line 107 of file Q2PBorehole.C.

{
  prepareNodalValues();
  DiracKernel::computeResidual();
}

jac()

Real Q2PBorehole::jac ( unsigned int  jvar )

protected

Calculates Jacobian.

Parameters

jvar	differentiate the residual wrt this variable

Definition at line 192 of file Q2PBorehole.C.

Referenced by computeQpJacobian(), and computeQpOffDiagJacobian().

{
  if (_i != _j)
    return 0.0;

  const Real character = _character.value(_t, _q_point[_qp]);
  if (character == 0.0)
    return 0.0;

  const Real bh_pressure =
      _p_bot +
      _unit_weight *
          (_q_point[_qp] -
           _bottom_point); // really want to use _q_point instaed of _current_point, i think?!

  const Real phi = 1;

  // Get the ID we initially assigned to this point
  const unsigned current_dirac_ptid = currentPointCachedID();

  // If getting the ID failed, fall back to the old bodge!
  // if (current_dirac_ptid == libMesh::invalid_uint)
  //  current_dirac_ptid = (_zs.size() > 2) ? 1 : 0;

  Real outflowp(0.0);

  const bool deriv_wrt_pp =
      (_var_is_pp && (jvar == _var.number())) || (!_var_is_pp && (jvar == _other_var_num));

  Real wc(0.0);
  if (current_dirac_ptid > 0)
  // contribution from half-segment "behind" this point
  {
    wc = wellConstant(_permeability[0],
                      _rot_matrix[current_dirac_ptid - 1],
                      _half_seg_len[current_dirac_ptid - 1],
                      _current_elem,
                      _rs[current_dirac_ptid]);
    if ((character < 0.0 && _pp[_i] < bh_pressure) || (character > 0.0 && _pp[_i] > bh_pressure))
    {
      // injection, so outflow<0 || // production, so outflow>0
      if (deriv_wrt_pp)
        outflowp += std::abs(character) * wc *
                    (_mobility[_i] * phi + _dmobility_dp[_i] * phi * (_pp[_i] - bh_pressure));
      else
        outflowp += std::abs(character) * wc * _dmobility_ds[_i] * phi * (_pp[_i] - bh_pressure);
    }
  }

  if (current_dirac_ptid < _zs.size() - 1 || _zs.size() == 1)
  // contribution from half-segment "ahead of" this point
  {
    wc = wellConstant(_permeability[0],
                      _rot_matrix[current_dirac_ptid],
                      _half_seg_len[current_dirac_ptid],
                      _current_elem,
                      _rs[current_dirac_ptid]);
    if ((character < 0.0 && _pp[_i] < bh_pressure) || (character > 0.0 && _pp[_i] > bh_pressure))
    {
      // injection, so outflow<0 || // production, so outflow>0
      if (deriv_wrt_pp)
        outflowp += std::abs(character) * wc *
                    (_mobility[_i] * phi + _dmobility_dp[_i] * phi * (_pp[_i] - bh_pressure));
      else
        outflowp += std::abs(character) * wc * _dmobility_ds[_i] * phi * (_pp[_i] - bh_pressure);
    }
  }

  return _test[_i][_qp] * outflowp;
}

parseNextLineReals()

bool PeacemanBorehole::parseNextLineReals ( std::ifstream &  ifs, std::vector< Real > &  myvec  )

protectedinherited

reads a space-separated line of floats from ifs and puts in myvec

Definition at line 158 of file PeacemanBorehole.C.

Referenced by PeacemanBorehole::PeacemanBorehole().

{
  std::string line;
  myvec.clear();
  bool gotline(false);
  if (getline(ifs, line))
  {
    gotline = true;

    // Harvest floats separated by whitespace
    std::istringstream iss(line);
    Real f;
    while (iss >> f)
    {
      myvec.push_back(f);
    }
  }
  return gotline;
}

prepareNodalValues()

void Q2PBorehole::prepareNodalValues ( )

protected

calculates the nodal values of pressure, mobility, and derivatives thereof

Definition at line 63 of file Q2PBorehole.C.

Referenced by computeJacobian(), and computeResidual().

{
  _num_nodes = _other_var_nodal.size();

  // set _pp and _sat variables
  _pp.resize(_num_nodes);
  _sat.resize(_num_nodes);
  if (_var_is_pp)
  {
    for (unsigned int nodenum = 0; nodenum < _num_nodes; ++nodenum)
    {
      _pp[nodenum] = _var.dofValues()[nodenum];
      _sat[nodenum] = _other_var_nodal[nodenum];
    }
  }
  else
  {
    for (unsigned int nodenum = 0; nodenum < _num_nodes; ++nodenum)
    {
      _pp[nodenum] = _other_var_nodal[nodenum];
      _sat[nodenum] = _var.dofValues()[nodenum];
    }
  }

  Real density;
  Real ddensity_dp;
  Real relperm;
  Real drelperm_ds;
  _mobility.resize(_num_nodes);
  _dmobility_dp.resize(_num_nodes);
  _dmobility_ds.resize(_num_nodes);
  for (unsigned int nodenum = 0; nodenum < _num_nodes; ++nodenum)
  {
    density = _density.density(_pp[nodenum]);
    ddensity_dp = _density.ddensity(_pp[nodenum]);
    relperm = _relperm.relperm(_sat[nodenum]);
    drelperm_ds = _relperm.drelperm(_sat[nodenum]);
    _mobility[nodenum] = density * relperm / _viscosity;
    _dmobility_dp[nodenum] = ddensity_dp * relperm / _viscosity;
    _dmobility_ds[nodenum] = density * drelperm_ds / _viscosity;
  }
}

wellConstant()

Real PeacemanBorehole::wellConstant ( const RealTensorValue &  perm, const RealTensorValue &  rot, const Real &  half_len, const Elem *  ele, const Real &  rad  )

protectedinherited

Calculates Peaceman's form of the borehole well constant Z Chen, Y Zhang, Well flow models for various numerical methods, Int J Num Analysis and Modeling, 3 (2008) 375-388.

Definition at line 194 of file PeacemanBorehole.C.

Referenced by computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), and RichardsBorehole::jac().

{
  if (_well_constant > 0)
    return _well_constant;

  // rot_perm has its "2" component lying along the half segment
  // we want to determine the eigenvectors of rot(0:1, 0:1), since, when
  // rotated back to the original frame we will determine the element
  // lengths along these directions
  const RealTensorValue rot_perm = (rot * perm) * rot.transpose();
  const Real trace2D = rot_perm(0, 0) + rot_perm(1, 1);
  const Real det2D = rot_perm(0, 0) * rot_perm(1, 1) - rot_perm(0, 1) * rot_perm(1, 0);
  const Real sq = std::sqrt(std::max(0.25 * trace2D * trace2D - det2D,
                                     0.0)); // the std::max accounts for wierdo precision loss
  const Real eig_val1 = 0.5 * trace2D + sq;
  const Real eig_val2 = 0.5 * trace2D - sq;
  RealVectorValue eig_vec1, eig_vec2;
  if (sq > std::abs(trace2D) * 1E-7) // matrix is not a multiple of the identity (1E-7 accounts for
                                     // precision in a crude way)
  {
    if (rot_perm(1, 0) != 0)
    {
      eig_vec1(0) = eig_val1 - rot_perm(1, 1);
      eig_vec1(1) = rot_perm(1, 0);
      eig_vec2(0) = eig_val2 - rot_perm(1, 1);
      eig_vec2(1) = rot_perm(1, 0);
    }
    else if (rot_perm(0, 1) != 0)
    {
      eig_vec1(0) = rot_perm(0, 1);
      eig_vec1(1) = eig_val1 - rot_perm(0, 0);
      eig_vec2(0) = rot_perm(0, 1);
      eig_vec2(1) = eig_val2 - rot_perm(0, 0);
    }
    else // off diagonal terms are both zero
    {
      eig_vec1(0) = 1;
      eig_vec2(1) = 1;
    }
  }
  else // matrix is basically a multiple of the identity
  {
    eig_vec1(0) = 1;
    eig_vec2(1) = 1;
  }

  // finally, rotate these to original frame and normalise
  eig_vec1 = rot.transpose() * eig_vec1;
  eig_vec1 /= std::sqrt(eig_vec1 * eig_vec1);
  eig_vec2 = rot.transpose() * eig_vec2;
  eig_vec2 /= std::sqrt(eig_vec2 * eig_vec2);

  // find the "length" of the element in these directions
  // TODO - probably better to use variance than max&min
  Real max1 = eig_vec1 * ele->point(0);
  Real max2 = eig_vec2 * ele->point(0);
  Real min1 = max1;
  Real min2 = max2;
  Real proj;
  for (unsigned int i = 1; i < ele->n_nodes(); i++)
  {
    proj = eig_vec1 * ele->point(i);
    max1 = (max1 < proj) ? proj : max1;
    min1 = (min1 < proj) ? min1 : proj;

    proj = eig_vec2 * ele->point(i);
    max2 = (max2 < proj) ? proj : max2;
    min2 = (min2 < proj) ? min2 : proj;
  }
  const Real ll1 = max1 - min1;
  const Real ll2 = max2 - min2;

  const Real r0 = _re_constant * std::sqrt(std::sqrt(eig_val1 / eig_val2) * std::pow(ll2, 2) +
                                           std::sqrt(eig_val2 / eig_val1) * std::pow(ll1, 2)) /
                  (std::pow(eig_val1 / eig_val2, 0.25) + std::pow(eig_val2 / eig_val1, 0.25));

  const Real effective_perm = std::sqrt(det2D);

  const Real halfPi = acos(0.0);

  if (r0 <= rad)
    mooseError("The effective element size (about 0.2-times-true-ele-size) for an element "
               "containing a Peaceman-type borehole must be (much) larger than the borehole radius "
               "for the Peaceman formulation to be correct.  Your element has effective size ",
               r0,
               " and the borehole radius is ",
               rad,
               "\n");

  return 4 * halfPi * effective_perm * half_len / std::log(r0 / rad);
}

Member Data Documentation

_bottom_point

Point PeacemanBorehole::_bottom_point

protectedinherited

the bottom point of the borehole (where bottom_pressure is defined)

Definition at line 95 of file PeacemanBorehole.h.

Referenced by computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), RichardsBorehole::jac(), and PeacemanBorehole::PeacemanBorehole().

_character

Function& PeacemanBorehole::_character

protectedinherited

If positive then the borehole acts as a sink (producion well) for porepressure > borehole pressure, and does nothing otherwise If negative then the borehole acts as a source (injection well) for porepressure < borehole pressure, and does nothing otherwise The flow rate to/from the borehole is multiplied by |character|, so usually character = +/- 1.

Definition at line 67 of file PeacemanBorehole.h.

Referenced by RichardsBorehole::computeQpJacobian(), computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), and RichardsBorehole::jac().

_density

const RichardsDensity& Q2PBorehole::_density

protected

fluid density

Definition at line 72 of file Q2PBorehole.h.

Referenced by prepareNodalValues().

_dmobility_dp

std::vector<Real> Q2PBorehole::_dmobility_dp

protected

nodal d(mobility)/d(porepressure)

Definition at line 105 of file Q2PBorehole.h.

Referenced by jac(), and prepareNodalValues().

_dmobility_ds

std::vector<Real> Q2PBorehole::_dmobility_ds

protected

nodal d(mobility)/d(saturation)

Definition at line 108 of file Q2PBorehole.h.

Referenced by jac(), and prepareNodalValues().

_half_seg_len

std::vector<Real> PeacemanBorehole::_half_seg_len

protectedinherited

0.5*(length of polyline segments between points)

Definition at line 98 of file PeacemanBorehole.h.

Referenced by computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), RichardsBorehole::jac(), and PeacemanBorehole::PeacemanBorehole().

_mobility

std::vector<Real> Q2PBorehole::_mobility

protected

nodal mobility

Definition at line 102 of file Q2PBorehole.h.

Referenced by computeQpResidual(), jac(), and prepareNodalValues().

_num_nodes

unsigned int Q2PBorehole::_num_nodes

protected

number of nodes in this element.

Definition at line 93 of file Q2PBorehole.h.

Referenced by prepareNodalValues().

_other_var_nodal

const VariableValue& Q2PBorehole::_other_var_nodal

protected

the other variable in the 2-phase system (this is saturation if Variable=porepressure, and viceversa)

Definition at line 78 of file Q2PBorehole.h.

Referenced by prepareNodalValues().

_other_var_num

const unsigned int Q2PBorehole::_other_var_num

protected

the variable number of the other variable

Definition at line 81 of file Q2PBorehole.h.

Referenced by computeQpOffDiagJacobian(), and jac().

_p_bot

const Real PeacemanBorehole::_p_bot

protectedinherited

bottomhole pressure of borehole

Definition at line 70 of file PeacemanBorehole.h.

Referenced by computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), and RichardsBorehole::jac().

_permeability

const MaterialProperty<RealTensorValue>& Q2PBorehole::_permeability

protected

permeability

Definition at line 90 of file Q2PBorehole.h.

Referenced by computeQpResidual(), and jac().

_pp

std::vector<Real> Q2PBorehole::_pp

protected

nodal porepressure

Definition at line 96 of file Q2PBorehole.h.

Referenced by computeQpResidual(), jac(), and prepareNodalValues().

_relperm

const RichardsRelPerm& Q2PBorehole::_relperm

protected

fluid relative permeability

Definition at line 75 of file Q2PBorehole.h.

Referenced by prepareNodalValues().

_rot_matrix

std::vector<RealTensorValue> PeacemanBorehole::_rot_matrix

protectedinherited

rotation matrix used in well_constant calculation

Definition at line 101 of file PeacemanBorehole.h.

Referenced by computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), RichardsBorehole::jac(), and PeacemanBorehole::PeacemanBorehole().

_rs

std::vector<Real> PeacemanBorehole::_rs

protectedinherited

radii of the borehole

Definition at line 83 of file PeacemanBorehole.h.

Referenced by computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), RichardsBorehole::jac(), and PeacemanBorehole::PeacemanBorehole().

_sat

std::vector<Real> Q2PBorehole::_sat

protected

nodal saturation

Definition at line 99 of file Q2PBorehole.h.

Referenced by prepareNodalValues().

_total_outflow_mass

RichardsSumQuantity& PeacemanBorehole::_total_outflow_mass

protectedinherited

This is used to hold the total fluid flowing into the borehole Hence, it is positive for production wells where fluid is flowing from porespace into the borehole and removed from the model.

Definition at line 80 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::addPoints(), computeQpResidual(), RichardsBorehole::computeQpResidual(), and PeacemanBorehole::PeacemanBorehole().

_unit_weight

const RealVectorValue PeacemanBorehole::_unit_weight

protectedinherited

unit weight of fluid in borehole (for calculating bottomhole pressure at each Dirac Point)

Definition at line 73 of file PeacemanBorehole.h.

Referenced by computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), and RichardsBorehole::jac().

_var_is_pp

const bool Q2PBorehole::_var_is_pp

protected

whether the Variable for this BC is porepressure or not

Definition at line 84 of file Q2PBorehole.h.

Referenced by jac(), and prepareNodalValues().

_viscosity

const Real Q2PBorehole::_viscosity

protected

viscosity

Definition at line 87 of file Q2PBorehole.h.

Referenced by prepareNodalValues().

_xs

std::vector<Real> PeacemanBorehole::_xs

protectedinherited

x points of the borehole

Definition at line 86 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::addPoints(), and PeacemanBorehole::PeacemanBorehole().

_ys

std::vector<Real> PeacemanBorehole::_ys

protectedinherited

y points of the borehole

Definition at line 89 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::addPoints(), and PeacemanBorehole::PeacemanBorehole().

_zs

std::vector<Real> PeacemanBorehole::_zs

protectedinherited

z points of borehole

Definition at line 92 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::addPoints(), computeQpResidual(), RichardsBorehole::computeQpResidual(), jac(), RichardsBorehole::jac(), and PeacemanBorehole::PeacemanBorehole().

---

The documentation for this class was generated from the following files:

• richards/include/dirackernels/Q2PBorehole.h
• richards/src/dirackernels/Q2PBorehole.C