Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : //  Rogers-Stallybrass-Clements version of effective saturation of water phase.
      11             : //  valid for residual saturations = 0, and viscosityOil = 2*viscosityWater.  (the "2" is important
      12             : //  here!).
      13             : // C Rogers, MP Stallybrass and DL Clements "On two phase filtration under gravity and with boundary
      14             : // infiltration: application of a Backlund transformation" Nonlinear Analysis Theory Methods and
      15             : // Applications 7 (1983) 785--799.
      16             : //
      17             : #include "RichardsSeff2waterRSC.h"
      18             : 
      19             : registerMooseObject("RichardsApp", RichardsSeff2waterRSC);
      20             : 
      21             : InputParameters
      22          10 : RichardsSeff2waterRSC::validParams()
      23             : {
      24          10 :   InputParameters params = RichardsSeff::validParams();
      25          20 :   params.addRequiredParam<Real>(
      26             :       "oil_viscosity",
      27             :       "Viscosity of oil (gas) phase.  It is assumed this is double the water-phase viscosity");
      28          20 :   params.addRequiredParam<Real>("scale_ratio",
      29             :                                 "This is porosity/permeability/beta^2, where beta "
      30             :                                 "may be chosen by the user (RSC define beta<0, but "
      31             :                                 "MOOSE only uses beta^2, so its sign is "
      32             :                                 "irrelevant).  It has dimensions [time]");
      33          20 :   params.addRequiredParam<Real>("shift", "effective saturation is a function of (Pc - shift)");
      34          10 :   params.addClassDescription("Rogers-Stallybrass-Clements version of effective saturation for the "
      35             :                              "water phase, valid for residual saturations = 0, and viscosityOil = "
      36             :                              "2*viscosityWater.  seff_water = 1/Sqrt(1 + Exp(Pc - shift)/scale)), "
      37             :                              "where scale = 0.25*scale_ratio*oil_viscosity");
      38          10 :   return params;
      39           0 : }
      40             : 
      41           5 : RichardsSeff2waterRSC::RichardsSeff2waterRSC(const InputParameters & parameters)
      42             :   : RichardsSeff(parameters),
      43           5 :     _oil_viscosity(getParam<Real>("oil_viscosity")),
      44          10 :     _scale_ratio(getParam<Real>("scale_ratio")),
      45          10 :     _shift(getParam<Real>("shift")),
      46           5 :     _scale(0.25 * _scale_ratio * _oil_viscosity)
      47             : {
      48           5 : }
      49             : 
      50             : Real
      51     1422644 : RichardsSeff2waterRSC::seff(std::vector<const VariableValue *> p, unsigned int qp) const
      52             : {
      53     1422644 :   Real pc = (*p[1])[qp] - (*p[0])[qp];
      54     1422644 :   return RichardsSeffRSC::seff(pc, _shift, _scale);
      55             : }
      56             : 
      57             : void
      58      798932 : RichardsSeff2waterRSC::dseff(std::vector<const VariableValue *> p,
      59             :                              unsigned int qp,
      60             :                              std::vector<Real> & result) const
      61             : {
      62      798932 :   Real pc = (*p[1])[qp] - (*p[0])[qp];
      63      798932 :   result[1] = RichardsSeffRSC::dseff(pc, _shift, _scale);
      64      798932 :   result[0] = -result[1];
      65      798932 : }
      66             : 
      67             : void
      68      466932 : RichardsSeff2waterRSC::d2seff(std::vector<const VariableValue *> p,
      69             :                               unsigned int qp,
      70             :                               std::vector<std::vector<Real>> & result) const
      71             : {
      72      466932 :   Real pc = (*p[1])[qp] - (*p[0])[qp];
      73      466932 :   result[1][1] = RichardsSeffRSC::d2seff(pc, _shift, _scale);
      74      466932 :   result[0][1] = -result[1][1];
      75      466932 :   result[1][0] = -result[1][1];
      76      466932 :   result[0][0] = result[1][1];
      77      466932 : }