RichardsBorehole Class Reference

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

#include <RichardsBorehole.h>

Inheritance diagram for RichardsBorehole:

Public Member Functions
	RichardsBorehole (const InputParameters &parameters)
	Creates a new RichardsBorehole 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 Note: at March2014 this is never called since moose does not have this functionality. More...

Protected Member Functions
void	prepareNodalValues ()
	calculates the nodal values of pressure, mobility, and derivatives thereof More...
Real	jac (unsigned int wrt_num)
	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 bool	_fully_upwind
	Whether to use full upwinding. More...
const RichardsVarNames &	_richards_name_UO
	Defines the richards variables in the simulation. More...
const unsigned int	_num_p
	number of richards variables More...
const unsigned int	_pvar
	The moose internal variable number of the richards variable of this Dirac Kernel. More...
const RichardsDensity *	_density_UO
	user object defining the density. Only used if _fully_upwind = true More...
const RichardsSeff *	_seff_UO
	user object defining the effective saturation. Only used if _fully_upwind = true More...
const RichardsRelPerm *	_relperm_UO
	user object defining the relative permeability. Only used if _fully_upwind = true More...
unsigned int	_num_nodes
	number of nodes in this element. Only used if _fully_upwind = true More...
std::vector< Real >	_mobility
	nodal values of mobility = density*relperm/viscosity These are used if _fully_upwind = true More...
std::vector< std::vector< Real > >	_dmobility_dv
	d(_mobility)/d(variable_ph) (variable_ph is the variable for phase=ph) These are used in the jacobian calculations if _fully_upwind = true More...
const MaterialProperty< std::vector< Real > > &	_pp
	fluid porepressure (or porepressures in case of multiphase) More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_dpp_dv
	d(porepressure_i)/d(variable_j) More...
const MaterialProperty< std::vector< Real > > &	_viscosity
	fluid viscosity More...
const MaterialProperty< RealTensorValue > &	_permeability
	material permeability More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_dseff_dv
	deriviatves of Seff wrt variables More...
const MaterialProperty< std::vector< Real > > &	_rel_perm
	relative permeability More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_drel_perm_dv
	d(relperm_i)/d(variable_j) More...
const MaterialProperty< std::vector< Real > > &	_density
	fluid density More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_ddensity_dv
	d(density_i)/d(variable_j) More...
std::vector< const VariableValue * >	_ps_at_nodes
	Holds the values of pressures at all the nodes of the element Only used if _fully_upwind = true Eg: _ps_at_nodes[_pvar] is a pointer to this variable's nodal porepressure values So: (*_ps_at_nodes[_pvar])[i] = _var.dofValues()[i] = porepressure of pressure-variable _pvar at node i. More...
const 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...

Private Attributes
const Real	_re_constant
	borehole constant More...
const Real	_well_constant
	well constant More...
const Real	_borehole_length
	borehole length. Note this is only used if there is only one borehole point More...
const RealVectorValue	_borehole_direction
	borehole direction. Note this is only used if there is only one borehole point More...
const std::string	_point_file
	File defining the geometry of the borehole. More...

Detailed Description

Approximates a borehole by a sequence of Dirac Points.

Definition at line 27 of file RichardsBorehole.h.

Constructor & Destructor Documentation

RichardsBorehole()

RichardsBorehole::RichardsBorehole

(

const InputParameters &

parameters

)

Creates a new RichardsBorehole 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 41 of file RichardsBorehole.C.

  : PeacemanBorehole(parameters),
    _fully_upwind(getParam<bool>("fully_upwind")),
    _richards_name_UO(getUserObject<RichardsVarNames>("richardsVarNames_UO")),
    _num_p(_richards_name_UO.num_v()),
    _pvar(_richards_name_UO.richards_var_num(_var.number())),
 
    // in the following, getUserObjectByName returns a reference (an alias) to a RichardsBLAH user
    // object, and the & turns it into a pointer
    _density_UO(_fully_upwind
                    ? &getUserObjectByName<RichardsDensity>(
                          getParam<std::vector<UserObjectName>>("density_UO")[_pvar])
                    : NULL),
    _seff_UO(_fully_upwind
                 ? &getUserObjectByName<RichardsSeff>(
                       getParam<std::vector<UserObjectName>>("seff_UO")[_pvar])
                 : NULL),
    _relperm_UO(_fully_upwind
                    ? &getUserObjectByName<RichardsRelPerm>(
                          getParam<std::vector<UserObjectName>>("relperm_UO")[_pvar])
                    : NULL),
 
    _num_nodes(0),
    _mobility(0),
    _dmobility_dv(0),
    _pp(getMaterialProperty<std::vector<Real>>("porepressure")),
    _dpp_dv(getMaterialProperty<std::vector<std::vector<Real>>>("dporepressure_dv")),
    _viscosity(getMaterialProperty<std::vector<Real>>("viscosity")),
    _permeability(getMaterialProperty<RealTensorValue>("permeability")),
    _dseff_dv(getMaterialProperty<std::vector<std::vector<Real>>>("ds_eff_dv")),
    _rel_perm(getMaterialProperty<std::vector<Real>>("rel_perm")),
    _drel_perm_dv(getMaterialProperty<std::vector<std::vector<Real>>>("drel_perm_dv")),
    _density(getMaterialProperty<std::vector<Real>>("density")),
    _ddensity_dv(getMaterialProperty<std::vector<std::vector<Real>>>("ddensity_dv"))
{
  _ps_at_nodes.resize(_num_p);
  for (unsigned int pnum = 0; pnum < _num_p; ++pnum)
    _ps_at_nodes[pnum] = _richards_name_UO.nodal_var(pnum);
 
  // To correctly compute the Jacobian terms,
  // tell MOOSE that this DiracKernel depends on all the Richards Vars
  const std::vector<MooseVariableFEBase *> & coupled_vars = _richards_name_UO.getCoupledMooseVars();
  for (unsigned int i = 0; i < coupled_vars.size(); i++)
    addMooseVariableDependency(coupled_vars[i]);
}

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 RichardsBorehole::computeJacobian ( )

virtual

Computes the Jacobian.

This just calls prepareNodalValues, if _fully_upwind then calls DiracKernel::computeJacobian

Definition at line 204 of file RichardsBorehole.C.

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

computeQpJacobian()

Real RichardsBorehole::computeQpJacobian ( )

virtual

Computes the diagonal part of the jacobian.

Definition at line 212 of file RichardsBorehole.C.

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

computeQpOffDiagJacobian()

Real RichardsBorehole::computeQpOffDiagJacobian ( unsigned int  jvar )

virtual

Computes the off-diagonal part of the jacobian Note: at March2014 this is never called since moose does not have this functionality.

Hence as of March2014 this has never been tested.

Definition at line 221 of file RichardsBorehole.C.

{
  if (_richards_name_UO.not_richards_var(jvar))
    return 0.0;
  const unsigned int dvar = _richards_name_UO.richards_var_num(jvar);
  return jac(dvar);
}

computeQpResidual()

Real RichardsBorehole::computeQpResidual ( )

virtual

Computes the Qp residual.

Definition at line 136 of file RichardsBorehole.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?!
 
  Real pp;
  Real mob;
  if (!_fully_upwind)
  {
    pp = _pp[_qp][_pvar];
    mob = _rel_perm[_qp][_pvar] * _density[_qp][_pvar] / _viscosity[_qp][_pvar];
  }
  else
  {
    pp = (*_ps_at_nodes[_pvar])[_i];
    mob = _mobility[_i];
  }
 
  // 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[_qp],
                      _rot_matrix[current_dirac_ptid - 1],
                      _half_seg_len[current_dirac_ptid - 1],
                      _current_elem,
                      _rs[current_dirac_ptid]);
    if ((character < 0.0 && pp < bh_pressure) || (character > 0.0 && pp > bh_pressure))
      // injection, so outflow<0 || // production, so outflow>0
      outflow += _test[_i][_qp] * std::abs(character) * wc * mob * (pp - 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[_qp],
                      _rot_matrix[current_dirac_ptid],
                      _half_seg_len[current_dirac_ptid],
                      _current_elem,
                      _rs[current_dirac_ptid]);
    if ((character < 0.0 && pp < bh_pressure) || (character > 0.0 && pp > bh_pressure))
      // injection, so outflow<0 || // production, so outflow>0
      outflow += _test[_i][_qp] * std::abs(character) * wc * mob * (pp - bh_pressure);
  }
 
  _total_outflow_mass.add(
      outflow * _dt); // this is not thread safe, but DiracKernel's aren't currently threaded
  return outflow;
}

computeResidual()

void RichardsBorehole::computeResidual ( )

virtual

Computes the residual.

This just calls prepareNodalValues, if _fully_upwind then calls DiracKernel::computeResidual

Definition at line 128 of file RichardsBorehole.C.

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

jac()

Real RichardsBorehole::jac ( unsigned int  wrt_num )

protected

Calculates Jacobian.

Parameters

wrt_num

differentiate the residual wrt this Richards variable

Definition at line 230 of file RichardsBorehole.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?!
 
  Real pp;
  Real dpp_dv;
  Real mob;
  Real dmob_dv;
  Real phi;
  if (!_fully_upwind)
  {
    pp = _pp[_qp][_pvar];
    dpp_dv = _dpp_dv[_qp][_pvar][wrt_num];
    mob = _rel_perm[_qp][_pvar] * _density[_qp][_pvar] / _viscosity[_qp][_pvar];
    dmob_dv = (_drel_perm_dv[_qp][_pvar][wrt_num] * _density[_qp][_pvar] +
               _rel_perm[_qp][_pvar] * _ddensity_dv[_qp][_pvar][wrt_num]) /
              _viscosity[_qp][_pvar];
    phi = _phi[_j][_qp];
  }
  else
  {
    if (_i != _j)
      return 0.0; // residual at node _i only depends on variables at that node
    pp = (*_ps_at_nodes[_pvar])[_i];
    dpp_dv =
        (_pvar == wrt_num ? 1 : 0); // NOTE: i'm assuming that the variables are pressure variables
    mob = _mobility[_i];
    dmob_dv = _dmobility_dv[_i][wrt_num];
    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);
 
  Real wc(0.0);
  if (current_dirac_ptid > 0)
  // contribution from half-segment "behind" this point
  {
    wc = wellConstant(_permeability[_qp],
                      _rot_matrix[current_dirac_ptid - 1],
                      _half_seg_len[current_dirac_ptid - 1],
                      _current_elem,
                      _rs[current_dirac_ptid]);
    if ((character < 0.0 && pp < bh_pressure) || (character > 0.0 && pp > bh_pressure))
      // injection, so outflow<0 || // production, so outflow>0
      outflowp += _test[_i][_qp] * std::abs(character) * wc *
                  (mob * phi * dpp_dv + dmob_dv * phi * (pp - bh_pressure));
  }
 
  if (current_dirac_ptid < _zs.size() - 1 || _zs.size() == 1)
  // contribution from half-segment "ahead of" this point
  {
    wc = wellConstant(_permeability[_qp],
                      _rot_matrix[current_dirac_ptid],
                      _half_seg_len[current_dirac_ptid],
                      _current_elem,
                      _rs[current_dirac_ptid]);
    if ((character < 0.0 && pp < bh_pressure) || (character > 0.0 && pp > bh_pressure))
      // injection, so outflow<0 || // production, so outflow>0
      outflowp += _test[_i][_qp] * std::abs(character) * wc *
                  (mob * phi * dpp_dv + dmob_dv * phi * (pp - bh_pressure));
  }
 
  return outflowp;
}

Referenced by computeQpJacobian(), and computeQpOffDiagJacobian().

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.

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

Referenced by PeacemanBorehole::PeacemanBorehole().

prepareNodalValues()

void RichardsBorehole::prepareNodalValues ( )

protected

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

Definition at line 88 of file RichardsBorehole.C.

{
  // NOTE: i'm assuming that all the richards variables are pressure values
 
  _num_nodes = (*_ps_at_nodes[_pvar]).size();
 
  Real p;
  Real density;
  Real ddensity_dp;
  Real seff;
  std::vector<Real> dseff_dp;
  Real relperm;
  Real drelperm_ds;
  _mobility.resize(_num_nodes);
  _dmobility_dv.resize(_num_nodes);
  dseff_dp.resize(_num_p);
  for (unsigned int nodenum = 0; nodenum < _num_nodes; ++nodenum)
  {
    // retrieve and calculate basic things at the node
    p = (*_ps_at_nodes[_pvar])[nodenum];    // pressure of fluid _pvar at node nodenum
    density = _density_UO->density(p);      // density of fluid _pvar at node nodenum
    ddensity_dp = _density_UO->ddensity(p); // d(density)/dP
    seff = _seff_UO->seff(_ps_at_nodes,
                          nodenum); // effective saturation of fluid _pvar at node nodenum
    _seff_UO->dseff(
        _ps_at_nodes, nodenum, dseff_dp); // d(seff)/d(P_ph), for ph = 0, ..., _num_p - 1
    relperm = _relperm_UO->relperm(seff); // relative permeability of fluid _pvar at node nodenum
    drelperm_ds = _relperm_UO->drelperm(seff); // d(relperm)/dseff
 
    // calculate the mobility and its derivatives wrt (variable_ph = porepressure_ph)
    _mobility[nodenum] =
        density * relperm / _viscosity[0][_pvar]; // assume viscosity is constant throughout element
    _dmobility_dv[nodenum].resize(_num_p);
    for (unsigned int ph = 0; ph < _num_p; ++ph)
      _dmobility_dv[nodenum][ph] = density * drelperm_ds * dseff_dp[ph] / _viscosity[0][_pvar];
    _dmobility_dv[nodenum][_pvar] += ddensity_dp * relperm / _viscosity[0][_pvar];
  }
}

Referenced by computeJacobian(), and computeResidual().

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.

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

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

Member Data Documentation

_borehole_direction

const RealVectorValue PeacemanBorehole::_borehole_direction

privateinherited

borehole direction. Note this is only used if there is only one borehole point

Definition at line 49 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::PeacemanBorehole().

_borehole_length

const Real PeacemanBorehole::_borehole_length

privateinherited

borehole length. Note this is only used if there is only one borehole point

Definition at line 46 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::PeacemanBorehole().

_bottom_point

Point PeacemanBorehole::_bottom_point

protectedinherited

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

Definition at line 94 of file PeacemanBorehole.h.

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

_character

const 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 66 of file PeacemanBorehole.h.

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

_ddensity_dv

const MaterialProperty<std::vector<std::vector<Real> > >& RichardsBorehole::_ddensity_dv

protected

d(density_i)/d(variable_j)

Definition at line 135 of file RichardsBorehole.h.

Referenced by jac().

_density

const MaterialProperty<std::vector<Real> >& RichardsBorehole::_density

protected

fluid density

Definition at line 132 of file RichardsBorehole.h.

Referenced by computeQpResidual(), and jac().

_density_UO

const RichardsDensity* RichardsBorehole::_density_UO

protected

user object defining the density. Only used if _fully_upwind = true

Definition at line 87 of file RichardsBorehole.h.

Referenced by prepareNodalValues().

_dmobility_dv

std::vector<std::vector<Real> > RichardsBorehole::_dmobility_dv

protected

d(_mobility)/d(variable_ph) (variable_ph is the variable for phase=ph) These are used in the jacobian calculations if _fully_upwind = true

Definition at line 108 of file RichardsBorehole.h.

Referenced by jac(), and prepareNodalValues().

_dpp_dv

const MaterialProperty<std::vector<std::vector<Real> > >& RichardsBorehole::_dpp_dv

protected

d(porepressure_i)/d(variable_j)

Definition at line 114 of file RichardsBorehole.h.

Referenced by jac().

_drel_perm_dv

const MaterialProperty<std::vector<std::vector<Real> > >& RichardsBorehole::_drel_perm_dv

protected

d(relperm_i)/d(variable_j)

Definition at line 129 of file RichardsBorehole.h.

Referenced by jac().

_dseff_dv

const MaterialProperty<std::vector<std::vector<Real> > >& RichardsBorehole::_dseff_dv

protected

deriviatves of Seff wrt variables

Definition at line 123 of file RichardsBorehole.h.

_fully_upwind

const bool RichardsBorehole::_fully_upwind

protected

Whether to use full upwinding.

Definition at line 75 of file RichardsBorehole.h.

Referenced by computeJacobian(), computeQpResidual(), computeResidual(), and jac().

_half_seg_len

std::vector<Real> PeacemanBorehole::_half_seg_len

protectedinherited

0.5*(length of polyline segments between points)

Definition at line 97 of file PeacemanBorehole.h.

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

_mobility

std::vector<Real> RichardsBorehole::_mobility

protected

nodal values of mobility = density*relperm/viscosity These are used if _fully_upwind = true

Definition at line 102 of file RichardsBorehole.h.

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

_num_nodes

unsigned int RichardsBorehole::_num_nodes

protected

number of nodes in this element. Only used if _fully_upwind = true

Definition at line 96 of file RichardsBorehole.h.

Referenced by prepareNodalValues().

_num_p

const unsigned int RichardsBorehole::_num_p

protected

number of richards variables

Definition at line 81 of file RichardsBorehole.h.

Referenced by prepareNodalValues(), and RichardsBorehole().

_p_bot

const Real PeacemanBorehole::_p_bot

protectedinherited

bottomhole pressure of borehole

Definition at line 69 of file PeacemanBorehole.h.

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

_permeability

const MaterialProperty<RealTensorValue>& RichardsBorehole::_permeability

protected

material permeability

Definition at line 120 of file RichardsBorehole.h.

Referenced by computeQpResidual(), and jac().

_point_file

const std::string PeacemanBorehole::_point_file

privateinherited

File defining the geometry of the borehole.

Each row has format radius x y z and the list of such points defines a polyline that is the borehole

Definition at line 56 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::PeacemanBorehole().

_pp

const MaterialProperty<std::vector<Real> >& RichardsBorehole::_pp

protected

fluid porepressure (or porepressures in case of multiphase)

Definition at line 111 of file RichardsBorehole.h.

Referenced by computeQpResidual(), and jac().

_ps_at_nodes

std::vector<const VariableValue *> RichardsBorehole::_ps_at_nodes

protected

Holds the values of pressures at all the nodes of the element Only used if _fully_upwind = true Eg: _ps_at_nodes[_pvar] is a pointer to this variable's nodal porepressure values So: (*_ps_at_nodes[_pvar])[i] = _var.dofValues()[i] = porepressure of pressure-variable _pvar at node i.

Definition at line 145 of file RichardsBorehole.h.

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

_pvar

const unsigned int RichardsBorehole::_pvar

protected

The moose internal variable number of the richards variable of this Dirac Kernel.

Definition at line 84 of file RichardsBorehole.h.

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

_re_constant

const Real PeacemanBorehole::_re_constant

privateinherited

borehole constant

Definition at line 40 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::wellConstant().

_rel_perm

const MaterialProperty<std::vector<Real> >& RichardsBorehole::_rel_perm

protected

relative permeability

Definition at line 126 of file RichardsBorehole.h.

Referenced by computeQpResidual(), and jac().

_relperm_UO

const RichardsRelPerm* RichardsBorehole::_relperm_UO

protected

user object defining the relative permeability. Only used if _fully_upwind = true

Definition at line 93 of file RichardsBorehole.h.

Referenced by prepareNodalValues().

_richards_name_UO

const RichardsVarNames& RichardsBorehole::_richards_name_UO

protected

Defines the richards variables in the simulation.

Definition at line 78 of file RichardsBorehole.h.

Referenced by computeQpOffDiagJacobian(), and RichardsBorehole().

_rot_matrix

std::vector<RealTensorValue> PeacemanBorehole::_rot_matrix

protectedinherited

rotation matrix used in well_constant calculation

Definition at line 100 of file PeacemanBorehole.h.

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

_rs

std::vector<Real> PeacemanBorehole::_rs

protectedinherited

radii of the borehole

Definition at line 82 of file PeacemanBorehole.h.

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

_seff_UO

const RichardsSeff* RichardsBorehole::_seff_UO

protected

user object defining the effective saturation. Only used if _fully_upwind = true

Definition at line 90 of file RichardsBorehole.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 79 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::addPoints(), Q2PBorehole::computeQpResidual(), 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 72 of file PeacemanBorehole.h.

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

_viscosity

const MaterialProperty<std::vector<Real> >& RichardsBorehole::_viscosity

protected

fluid viscosity

Definition at line 117 of file RichardsBorehole.h.

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

_well_constant

const Real PeacemanBorehole::_well_constant

privateinherited

well constant

Definition at line 43 of file PeacemanBorehole.h.

Referenced by PeacemanBorehole::wellConstant().

_xs

std::vector<Real> PeacemanBorehole::_xs

protectedinherited

x points of the borehole

Definition at line 85 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 88 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 91 of file PeacemanBorehole.h.

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

---

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

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