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             : //  "PowerGas" form of relative permeability
      11             : //
      12             : #include "Q2PRelPermPowerGas.h"
      13             : 
      14             : registerMooseObject("RichardsApp", Q2PRelPermPowerGas);
      15             : 
      16             : InputParameters
      17          46 : Q2PRelPermPowerGas::validParams()
      18             : {
      19          46 :   InputParameters params = RichardsRelPerm::validParams();
      20          92 :   params.addRequiredRangeCheckedParam<Real>(
      21             :       "simm",
      22             :       "simm >= 0 & simm < 1",
      23             :       "Immobile saturation.  Must be between 0 and 1.   Define s = "
      24             :       "seff/(1 - simm).  Then relperm = 1 - (n+1)s^n + ns^(n+1)");
      25          92 :   params.addRequiredRangeCheckedParam<Real>("n",
      26             :                                             "n >= 2",
      27             :                                             "Exponent.  Must be >= 2.   Define s = "
      28             :                                             "(eff/(1 - simm).  Then relperm = 1 - "
      29             :                                             "(n+1)s^n + ns^(n+1)");
      30          46 :   params.addClassDescription("Power form of relative permeability that might be useful for gases "
      31             :                              "as a function of water saturation in Q2P models.  Define s = seff/(1 "
      32             :                              "- simm).  Then relperm = 1 - (n+1)s^n + ns^(n+1) if seff<1-simm, "
      33             :                              "otherwise relperm=1.  Here seff is the water saturation");
      34          46 :   return params;
      35           0 : }
      36             : 
      37          21 : Q2PRelPermPowerGas::Q2PRelPermPowerGas(const InputParameters & parameters)
      38          63 :   : RichardsRelPerm(parameters), _simm(getParam<Real>("simm")), _n(getParam<Real>("n"))
      39             : {
      40          21 : }
      41             : 
      42             : Real
      43       34604 : Q2PRelPermPowerGas::relperm(Real seff) const
      44             : {
      45       34604 :   if (seff >= 1.0 - _simm)
      46             :     return 0.0;
      47             : 
      48       34542 :   if (seff <= 0)
      49             :     return 1.0;
      50             : 
      51       34515 :   Real s_internal = seff / (1.0 - _simm);
      52       34515 :   Real krel = 1 - (_n + 1) * std::pow(s_internal, _n) + _n * std::pow(s_internal, _n + 1);
      53             : 
      54             :   // bound, just in case
      55       34515 :   if (krel < 0)
      56             :   {
      57             :     krel = 0;
      58             :   }
      59       34515 :   if (krel > 1)
      60             :   {
      61             :     krel = 1;
      62             :   }
      63             :   return krel;
      64             : }
      65             : 
      66             : Real
      67       34526 : Q2PRelPermPowerGas::drelperm(Real seff) const
      68             : {
      69       34526 :   if (seff >= 1.0 - _simm)
      70             :     return 0.0;
      71             : 
      72       34464 :   if (seff <= 0)
      73             :     return 0.0;
      74             : 
      75       34437 :   Real s_internal = seff / (1.0 - _simm);
      76             :   Real krelp =
      77       34437 :       -(_n + 1) * _n * std::pow(s_internal, _n - 1) + _n * (_n + 1) * std::pow(s_internal, _n);
      78       34437 :   return krelp / (1.0 - _simm);
      79             : }
      80             : 
      81             : Real
      82         606 : Q2PRelPermPowerGas::d2relperm(Real seff) const
      83             : {
      84         606 :   if (seff >= 1.0 - _simm)
      85             :     return 0.0;
      86             : 
      87         606 :   if (seff <= 0)
      88             :     return 0.0;
      89             : 
      90         606 :   Real s_internal = seff / (1.0 - _simm);
      91         606 :   Real krelpp = -(_n + 1) * _n * (_n - 1) * std::pow(s_internal, _n - 2) +
      92         606 :                 _n * (_n + 1) * _n * std::pow(s_internal, _n - 1);
      93         606 :   return krelpp / std::pow(1.0 - _simm, 2);
      94             : }