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 "PorousFlowMassFraction.h"
      11             : 
      12             : registerMooseObject("PorousFlowApp", PorousFlowMassFraction);
      13             : registerMooseObject("PorousFlowApp", ADPorousFlowMassFraction);
      14             : 
      15             : template <bool is_ad>
      16             : InputParameters
      17       31702 : PorousFlowMassFractionTempl<is_ad>::validParams()
      18             : {
      19       31702 :   InputParameters params = PorousFlowMaterialVectorBase::validParams();
      20       63404 :   params.addCoupledVar(
      21             :       "mass_fraction_vars",
      22             :       "List of variables that represent the mass fractions.  Format is 'f_ph0^c0 "
      23             :       "f_ph0^c1 f_ph0^c2 ... f_ph0^c(N-2) f_ph1^c0 f_ph1^c1 fph1^c2 ... "
      24             :       "fph1^c(N-2) ... fphP^c0 f_phP^c1 fphP^c2 ... fphP^c(N-2)' where "
      25             :       "N=num_components and P=num_phases, and it is assumed that "
      26             :       "f_ph^c(N-1)=1-sum(f_ph^c,{c,0,N-2}) so that f_ph^c(N-1) need not be given.  If no "
      27             :       "variables are provided then num_phases=1=num_components.");
      28       63404 :   params.addPrivateParam<std::string>("pf_material_type", "mass_fraction");
      29       31702 :   params.addClassDescription("This Material forms a std::vector<std::vector ...> of mass-fractions "
      30             :                              "out of the individual mass fractions");
      31       31702 :   return params;
      32           0 : }
      33             : 
      34             : template <bool is_ad>
      35       25347 : PorousFlowMassFractionTempl<is_ad>::PorousFlowMassFractionTempl(const InputParameters & parameters)
      36             :   : PorousFlowMaterialVectorBase(parameters),
      37       17223 :     _mass_frac(_nodal_material ? declareGenericProperty<std::vector<std::vector<Real>>, is_ad>(
      38             :                                      "PorousFlow_mass_frac_nodal")
      39       41595 :                                : declareGenericProperty<std::vector<std::vector<Real>>, is_ad>(
      40             :                                      "PorousFlow_mass_frac_qp")),
      41       50694 :     _grad_mass_frac(_nodal_material
      42       25347 :                         ? nullptr
      43       33471 :                         : &declareGenericProperty<std::vector<std::vector<RealGradient>>, is_ad>(
      44             :                               "PorousFlow_grad_mass_frac_qp")),
      45       49692 :     _dmass_frac_dvar(is_ad ? nullptr
      46       24345 :                      : _nodal_material
      47       17223 :                          ? &declareProperty<std::vector<std::vector<std::vector<Real>>>>(
      48             :                                "dPorousFlow_mass_frac_nodal_dvar")
      49       31467 :                          : &declareProperty<std::vector<std::vector<std::vector<Real>>>>(
      50             :                                "dPorousFlow_mass_frac_qp_dvar")),
      51       61422 :     _num_passed_mf_vars(isParamValid("mass_fraction_vars") ? coupledComponents("mass_fraction_vars")
      52       25347 :                                                            : 0)
      53             : {
      54       25347 :   if (_num_phases < 1 || _num_components < 1)
      55           0 :     mooseError("PorousFlowMassFraction: The Dictator proclaims that the number of phases is ",
      56           0 :                _num_phases,
      57             :                " and the number of components is ",
      58           0 :                _num_components,
      59             :                ", and stipulates that you should not use PorousFlowMassFraction in this case");
      60             : 
      61       25347 :   if (_num_passed_mf_vars != _num_phases * (_num_components - 1))
      62           2 :     paramError("mass_fraction_vars",
      63             :                "This value must be equal to the Dictator's num_phases (",
      64             :                _num_phases,
      65             :                ") multiplied by num_components-1 (",
      66             :                _num_components - 1,
      67             :                ")");
      68             : 
      69       25345 :   _mf_vars_num.resize(_num_passed_mf_vars);
      70       25345 :   _mf_vars.resize(_num_passed_mf_vars);
      71       25345 :   _grad_mf_vars.resize(_num_passed_mf_vars);
      72       44820 :   for (unsigned i = 0; i < _num_passed_mf_vars; ++i)
      73             :   {
      74             :     // If mass_fraction_vars are elemental AuxVariables (or constants), we want to use
      75             :     // coupledGenericValue() rather than coupledGenericDofValue()
      76             :     const bool is_nodal =
      77       38950 :         isCoupled("mass_fraction_vars") ? getFieldVar("mass_fraction_vars", i)->isNodal() : false;
      78             : 
      79       19475 :     _mf_vars_num[i] = coupled("mass_fraction_vars", i);
      80       19475 :     _mf_vars[i] =
      81       19475 :         (_nodal_material && is_nodal ? &coupledGenericDofValue<is_ad>("mass_fraction_vars", i)
      82       27193 :                                      : &coupledGenericValue<is_ad>("mass_fraction_vars", i));
      83       19475 :     _grad_mf_vars[i] = &coupledGenericGradient<is_ad>("mass_fraction_vars", i);
      84             :   }
      85       25345 : }
      86             : 
      87             : template <bool is_ad>
      88             : void
      89     2395258 : PorousFlowMassFractionTempl<is_ad>::initQpStatefulProperties()
      90             : {
      91             :   // all we need to do is compute _mass_frac for _nodal_materials
      92             :   // but the following avoids code duplication
      93     2395258 :   computeQpProperties();
      94     2395258 : }
      95             : 
      96             : template <bool is_ad>
      97             : void
      98    51998101 : PorousFlowMassFractionTempl<is_ad>::computeQpProperties()
      99             : {
     100             :   // size all properties correctly
     101    51998101 :   _mass_frac[_qp].resize(_num_phases);
     102             : 
     103             :   if (!is_ad)
     104    51460723 :     (*_dmass_frac_dvar)[_qp].resize(_num_phases);
     105             : 
     106    51998101 :   if (!_nodal_material)
     107     8348492 :     (*_grad_mass_frac)[_qp].resize(_num_phases);
     108             : 
     109   107543490 :   for (unsigned int ph = 0; ph < _num_phases; ++ph)
     110             :   {
     111    55545389 :     _mass_frac[_qp][ph].resize(_num_components);
     112             : 
     113             :     if (!is_ad)
     114             :     {
     115    54964621 :       (*_dmass_frac_dvar)[_qp][ph].resize(_num_components);
     116   129675396 :       for (unsigned int comp = 0; comp < _num_components; ++comp)
     117    74710775 :         (*_dmass_frac_dvar)[_qp][ph][comp].assign(_num_var, 0.0);
     118             :     }
     119             : 
     120    55545389 :     if (!_nodal_material)
     121     8960868 :       (*_grad_mass_frac)[_qp][ph].resize(_num_components);
     122             :   }
     123             : 
     124             :   // compute the values and derivatives
     125             :   unsigned int i = 0;
     126   107543490 :   for (unsigned int ph = 0; ph < _num_phases; ++ph)
     127             :   {
     128      580768 :     GenericReal<is_ad> total_mass_frac = 0;
     129             : 
     130    55545389 :     if (!_nodal_material)
     131     8960868 :       (*_grad_mass_frac)[_qp][ph][_num_components - 1] = 0.0;
     132             : 
     133    75509443 :     for (unsigned int comp = 0; comp < _num_components - 1; ++comp)
     134             :     {
     135    19964054 :       _mass_frac[_qp][ph][comp] = (*_mf_vars[i])[_qp];
     136    19964054 :       total_mass_frac += _mass_frac[_qp][ph][comp];
     137             : 
     138    19964054 :       if (!_nodal_material)
     139             :       {
     140     5914682 :         (*_grad_mass_frac)[_qp][ph][comp] = (*_grad_mf_vars[i])[_qp];
     141     5914682 :         (*_grad_mass_frac)[_qp][ph][_num_components - 1] -= (*_grad_mf_vars[i])[_qp];
     142             :       }
     143             : 
     144    19746154 :       if (!is_ad && _dictator.isPorousFlowVariable(_mf_vars_num[i]))
     145             :       {
     146             :         // _mf_vars[i] is a PorousFlow variable
     147    13191354 :         const unsigned int pf_var_num = _dictator.porousFlowVariableNum(_mf_vars_num[i]);
     148    13191354 :         (*_dmass_frac_dvar)[_qp][ph][comp][pf_var_num] = 1.0;
     149    13191354 :         (*_dmass_frac_dvar)[_qp][ph][_num_components - 1][pf_var_num] = -1.0;
     150             :       }
     151    19964054 :       i++;
     152             :     }
     153             : 
     154    56126157 :     _mass_frac[_qp][ph][_num_components - 1] = 1.0 - total_mass_frac;
     155             :   }
     156    51998101 : }
     157             : 
     158             : template class PorousFlowMassFractionTempl<false>;
     159             : template class PorousFlowMassFractionTempl<true>;