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             : #include "PorousFlowDesorpedMassTimeDerivative.h"
      11             : 
      12             : #include "MooseVariable.h"
      13             : 
      14             : #include "libmesh/quadrature.h"
      15             : 
      16             : registerMooseObject("PorousFlowApp", PorousFlowDesorpedMassTimeDerivative);
      17             : registerMooseObject("PorousFlowApp", ADPorousFlowDesorpedMassTimeDerivative);
      18             : 
      19             : template <bool is_ad>
      20             : InputParameters
      21         102 : PorousFlowDesorpedMassTimeDerivativeTempl<is_ad>::validParams()
      22             : {
      23             :   InputParameters params = GenericKernel<is_ad>::validParams();
      24         204 :   params.set<MultiMooseEnum>("vector_tags") = "time";
      25         204 :   params.set<MultiMooseEnum>("matrix_tags") = "system time";
      26         204 :   params.addRequiredParam<UserObjectName>(
      27             :       "PorousFlowDictator", "The UserObject that holds the list of PorousFlow variable names.");
      28         204 :   params.addRequiredCoupledVar(
      29             :       "conc_var", "The variable that represents the concentration of desorped species");
      30         102 :   params.addClassDescription("Desorped component mass derivative wrt time.");
      31         102 :   return params;
      32           0 : }
      33             : 
      34             : template <bool is_ad>
      35          54 : PorousFlowDesorpedMassTimeDerivativeTempl<is_ad>::PorousFlowDesorpedMassTimeDerivativeTempl(
      36             :     const InputParameters & parameters)
      37             :   : GenericKernel<is_ad>(parameters),
      38          54 :     _dictator(this->template getUserObject<PorousFlowDictator>("PorousFlowDictator")),
      39          54 :     _conc_var_number(this->coupled("conc_var")),
      40          54 :     _conc(this->template coupledGenericValue<is_ad>("conc_var")),
      41          54 :     _conc_old(this->coupledValueOld("conc_var")),
      42         108 :     _porosity(this->template getGenericMaterialProperty<Real, is_ad>("PorousFlow_porosity_qp")),
      43         108 :     _porosity_old(this->template getMaterialPropertyOld<Real>("PorousFlow_porosity_qp")),
      44          54 :     _dporosity_dvar(is_ad ? nullptr
      45          47 :                           : &this->template getMaterialProperty<std::vector<Real>>(
      46             :                                 "dPorousFlow_porosity_qp_dvar")),
      47          54 :     _dporosity_dgradvar(is_ad ? nullptr
      48          47 :                               : &this->template getMaterialProperty<std::vector<RealGradient>>(
      49          54 :                                     "dPorousFlow_porosity_qp_dgradvar"))
      50             : {
      51          54 : }
      52             : 
      53             : template <bool is_ad>
      54             : GenericReal<is_ad>
      55        6672 : PorousFlowDesorpedMassTimeDerivativeTempl<is_ad>::computeQpResidual()
      56             : {
      57        6672 :   GenericReal<is_ad> c = (1.0 - _porosity[_qp]) * _conc[_qp];
      58        6672 :   Real c_old = (1.0 - _porosity_old[_qp]) * _conc_old[_qp];
      59        6672 :   return _test[_i][_qp] * (c - c_old) / this->_dt;
      60             : }
      61             : 
      62             : template <bool is_ad>
      63             : Real
      64       29152 : PorousFlowDesorpedMassTimeDerivativeTempl<is_ad>::computeQpJacobian()
      65             : {
      66       29152 :   return computeQpJac(_var.number());
      67             : }
      68             : 
      69             : template <bool is_ad>
      70             : Real
      71        8192 : PorousFlowDesorpedMassTimeDerivativeTempl<is_ad>::computeQpOffDiagJacobian(unsigned int jvar)
      72             : {
      73        8192 :   return computeQpJac(jvar);
      74             : }
      75             : 
      76             : template <bool is_ad>
      77             : Real
      78       37344 : PorousFlowDesorpedMassTimeDerivativeTempl<is_ad>::computeQpJac(unsigned int jvar)
      79             : {
      80             :   if constexpr (!is_ad)
      81             :   {
      82             :     Real deriv = 0.0;
      83             : 
      84       37344 :     if (jvar == _conc_var_number)
      85        4064 :       deriv = (1.0 - this->_porosity[this->_qp]) * this->_phi[this->_j][this->_qp];
      86             : 
      87       37344 :     if (_dictator.notPorousFlowVariable(jvar))
      88           0 :       return this->_test[this->_i][this->_qp] * deriv / this->_dt;
      89       37344 :     const unsigned int pvar = _dictator.porousFlowVariableNum(jvar);
      90             : 
      91       37344 :     deriv -= (*_dporosity_dgradvar)[this->_qp][pvar] * this->_grad_phi[this->_j][this->_qp] *
      92       37344 :              this->_conc[this->_qp];
      93       37344 :     deriv -= (*_dporosity_dvar)[this->_qp][pvar] * this->_phi[this->_j][this->_qp] *
      94             :              this->_conc[this->_qp];
      95             : 
      96       37344 :     return this->_test[this->_i][this->_qp] * deriv / this->_dt;
      97             :   }
      98             :   else
      99             :     libmesh_ignore(jvar);
     100           0 :   return 0.0;
     101             : }
     102             : 
     103             : template class PorousFlowDesorpedMassTimeDerivativeTempl<false>;
     104             : template class PorousFlowDesorpedMassTimeDerivativeTempl<true>;