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 "FlowModelGasMix.h"
      11             : #include "FlowChannelBase.h"
      12             : #include "THMNames.h"
      13             : 
      14             : registerMooseObject("ThermalHydraulicsApp", FlowModelGasMix);
      15             : 
      16             : InputParameters
      17          38 : FlowModelGasMix::validParams()
      18             : {
      19          38 :   InputParameters params = FlowModel1PhaseBase::validParams();
      20             : 
      21          76 :   params.addRequiredParam<Real>("scaling_factor_xirhoA",
      22             :                                 "Scaling factor for the secondary component mass equation");
      23          76 :   params.addRequiredParam<Real>("scaling_factor_rhoA",
      24             :                                 "Scaling factor for the mixture mass equation");
      25          76 :   params.addRequiredParam<Real>("scaling_factor_rhouA", "Scaling factor for the momentum equation");
      26          76 :   params.addRequiredParam<Real>("scaling_factor_rhoEA", "Scaling factor for the energy equation");
      27             : 
      28          38 :   return params;
      29           0 : }
      30             : 
      31          19 : FlowModelGasMix::FlowModelGasMix(const InputParameters & params) : FlowModel1PhaseBase(params) {}
      32             : 
      33             : void
      34          19 : FlowModelGasMix::addVariables()
      35             : {
      36          19 :   FlowModel1PhaseBase::addVariables();
      37             : 
      38          19 :   const std::vector<SubdomainName> & subdomains = _flow_channel.getSubdomainNames();
      39             : 
      40          38 :   _sim.addSimVariable(
      41          38 :       true, THM::XIRHOA, _fe_type, subdomains, getParam<Real>("scaling_factor_xirhoA"));
      42          19 :   _sim.addSimVariable(false, THM::MASS_FRACTION, _fe_type, subdomains);
      43          19 : }
      44             : 
      45             : Real
      46          19 : FlowModelGasMix::getScalingFactorRhoA() const
      47             : {
      48          38 :   return getParam<Real>("scaling_factor_rhoA");
      49             : }
      50             : 
      51             : Real
      52          19 : FlowModelGasMix::getScalingFactorRhoUA() const
      53             : {
      54          38 :   return getParam<Real>("scaling_factor_rhouA");
      55             : }
      56             : 
      57             : Real
      58          19 : FlowModelGasMix::getScalingFactorRhoEA() const
      59             : {
      60          38 :   return getParam<Real>("scaling_factor_rhoEA");
      61             : }
      62             : 
      63             : std::vector<VariableName>
      64          38 : FlowModelGasMix::solutionVariableNames() const
      65             : {
      66         190 :   return {THM::XIRHOA, THM::RHOA, THM::RHOUA, THM::RHOEA};
      67           0 : }
      68             : 
      69             : void
      70          19 : FlowModelGasMix::addInitialConditions()
      71             : {
      72          19 :   FlowModel1PhaseBase::addInitialConditions();
      73             : 
      74          19 :   if (ICParametersAreValid())
      75             :   {
      76          19 :     addXiRhoAIC();
      77          38 :     addFunctionIC(THM::MASS_FRACTION,
      78          19 :                   _flow_channel.getParam<FunctionName>("initial_mass_fraction"));
      79             :   }
      80          19 : }
      81             : 
      82             : void
      83          19 : FlowModelGasMix::addXiRhoAIC()
      84             : {
      85          19 :   const std::string class_name = "VariableProductIC";
      86          19 :   InputParameters params = _factory.getValidParams(class_name);
      87          38 :   params.set<VariableName>("variable") = THM::XIRHOA;
      88          38 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
      89          76 :   params.set<std::vector<VariableName>>("values") = {THM::MASS_FRACTION, THM::RHOA};
      90          38 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "xirhoA_ic"), params);
      91          38 : }
      92             : 
      93             : void
      94          19 : FlowModelGasMix::addRhoEAIC()
      95             : {
      96          19 :   const std::string class_name = "FlowModelGasMixIC";
      97          19 :   InputParameters params = _factory.getValidParams(class_name);
      98          38 :   params.set<VariableName>("variable") = THM::RHOEA;
      99          19 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     100          38 :   params.set<MooseEnum>("quantity") = "rhoEA";
     101          38 :   params.set<FunctionName>("mass_fraction") =
     102          19 :       _flow_channel.getParam<FunctionName>("initial_mass_fraction");
     103          57 :   params.set<FunctionName>("pressure") = _flow_channel.getParam<FunctionName>("initial_p");
     104          57 :   params.set<FunctionName>("temperature") = _flow_channel.getParam<FunctionName>("initial_T");
     105          57 :   params.set<FunctionName>("velocity") = _flow_channel.getParam<FunctionName>("initial_vel");
     106          57 :   params.set<std::vector<VariableName>>("area") = {THM::AREA};
     107          19 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     108          38 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rhoEA_ic"), params);
     109          38 : }
     110             : 
     111             : void
     112          19 : FlowModelGasMix::addDensityIC()
     113             : {
     114          19 :   const std::string class_name = "FlowModelGasMixIC";
     115          19 :   InputParameters params = _factory.getValidParams(class_name);
     116          38 :   params.set<VariableName>("variable") = THM::DENSITY;
     117          19 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     118          38 :   params.set<MooseEnum>("quantity") = "rho";
     119          38 :   params.set<FunctionName>("mass_fraction") =
     120          19 :       _flow_channel.getParam<FunctionName>("initial_mass_fraction");
     121          57 :   params.set<FunctionName>("pressure") = _flow_channel.getParam<FunctionName>("initial_p");
     122          57 :   params.set<FunctionName>("temperature") = _flow_channel.getParam<FunctionName>("initial_T");
     123          57 :   params.set<FunctionName>("velocity") = _flow_channel.getParam<FunctionName>("initial_vel");
     124          57 :   params.set<std::vector<VariableName>>("area") = {THM::AREA};
     125          19 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     126          38 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rho_ic"), params);
     127          38 : }
     128             : 
     129             : void
     130          19 : FlowModelGasMix::addKernels()
     131             : {
     132          19 :   FlowModel1PhaseBase::addKernels();
     133             : 
     134          19 :   addTimeDerivativeKernelIfTransient(THM::XIRHOA);
     135          19 : }
     136             : 
     137             : void
     138          19 : FlowModelGasMix::addDGKernels()
     139             : {
     140          19 :   FlowModel1PhaseBase::addDGKernels();
     141             : 
     142          19 :   addMassDiffusionSpeciesDGKernel();
     143          19 :   addMassDiffusionEnergyDGKernel();
     144          19 : }
     145             : 
     146             : void
     147          19 : FlowModelGasMix::addMassDiffusionSpeciesDGKernel()
     148             : {
     149          19 :   const std::string class_name = "MassDiffusionSpeciesGasMixDGKernel";
     150          19 :   InputParameters params = _factory.getValidParams(class_name);
     151          38 :   params.set<NonlinearVariableName>("variable") = THM::XIRHOA;
     152          38 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     153          57 :   params.set<std::vector<VariableName>>("A_linear") = {THM::AREA_LINEAR};
     154          38 :   params.set<MaterialPropertyName>("density") = THM::DENSITY;
     155          38 :   params.set<MaterialPropertyName>("diffusion_coefficient") = THM::MASS_DIFFUSION_COEFFICIENT;
     156          38 :   params.set<MaterialPropertyName>("mass_fraction") = THM::MASS_FRACTION;
     157          38 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     158          19 :   params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     159          38 :   _sim.addDGKernel(class_name, genName(_comp_name, "mass_diffusion_species"), params);
     160          38 : }
     161             : 
     162             : void
     163          19 : FlowModelGasMix::addMassDiffusionEnergyDGKernel()
     164             : {
     165          19 :   const std::string class_name = "MassDiffusionEnergyGasMixDGKernel";
     166          19 :   InputParameters params = _factory.getValidParams(class_name);
     167          38 :   params.set<NonlinearVariableName>("variable") = THM::RHOEA;
     168          38 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     169          57 :   params.set<std::vector<VariableName>>("A_linear") = {THM::AREA_LINEAR};
     170          38 :   params.set<MaterialPropertyName>("density") = THM::DENSITY;
     171          38 :   params.set<MaterialPropertyName>("pressure") = THM::PRESSURE;
     172          38 :   params.set<MaterialPropertyName>("temperature") = THM::TEMPERATURE;
     173          38 :   params.set<MaterialPropertyName>("velocity") = THM::VELOCITY;
     174          38 :   params.set<MaterialPropertyName>("diffusion_coefficient") = THM::MASS_DIFFUSION_COEFFICIENT;
     175          38 :   params.set<MaterialPropertyName>("mass_fraction") = THM::MASS_FRACTION;
     176          38 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     177          19 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     178          19 :   params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     179          38 :   _sim.addDGKernel(class_name, genName(_comp_name, "mass_diffusion_energy"), params);
     180          38 : }
     181             : 
     182             : void
     183          19 : FlowModelGasMix::addAuxKernels()
     184             : {
     185          19 :   FlowModel1PhaseBase::addAuxKernels();
     186          19 :   addMassFractionAux();
     187          19 : }
     188             : 
     189             : void
     190          19 : FlowModelGasMix::addPressureAux()
     191             : {
     192          19 :   const std::string class_name = "FlowModelGasMixAux";
     193          19 :   InputParameters params = _factory.getValidParams(class_name);
     194          38 :   params.set<AuxVariableName>("variable") = THM::PRESSURE;
     195          19 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     196          38 :   params.set<MooseEnum>("quantity") = "p";
     197          57 :   params.set<std::vector<VariableName>>("xirhoA") = {THM::XIRHOA};
     198          57 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     199          57 :   params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     200          57 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     201          57 :   params.set<std::vector<VariableName>>("area") = {THM::AREA};
     202          19 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     203          76 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     204          38 :   _sim.addAuxKernel(class_name, genName(_comp_name, "p_aux"), params);
     205          57 : }
     206             : 
     207             : void
     208          19 : FlowModelGasMix::addTemperatureAux()
     209             : {
     210          19 :   const std::string class_name = "FlowModelGasMixAux";
     211          19 :   InputParameters params = _factory.getValidParams(class_name);
     212          38 :   params.set<AuxVariableName>("variable") = THM::TEMPERATURE;
     213          19 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     214          38 :   params.set<MooseEnum>("quantity") = "T";
     215          57 :   params.set<std::vector<VariableName>>("xirhoA") = {THM::XIRHOA};
     216          57 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     217          57 :   params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     218          57 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     219          57 :   params.set<std::vector<VariableName>>("area") = {THM::AREA};
     220          19 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     221          76 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     222          38 :   _sim.addAuxKernel(class_name, genName(_comp_name, "T_aux"), params);
     223          57 : }
     224             : 
     225             : void
     226          19 : FlowModelGasMix::addMassFractionAux()
     227             : {
     228          19 :   const std::string class_name = "QuotientAux";
     229          19 :   InputParameters params = _factory.getValidParams(class_name);
     230          38 :   params.set<AuxVariableName>("variable") = THM::MASS_FRACTION;
     231          38 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     232          57 :   params.set<std::vector<VariableName>>("numerator") = {THM::XIRHOA};
     233          57 :   params.set<std::vector<VariableName>>("denominator") = {THM::RHOA};
     234          76 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     235          38 :   _sim.addAuxKernel(class_name, genName(_comp_name, "xi_aux"), params);
     236          57 : }
     237             : 
     238             : void
     239          19 : FlowModelGasMix::addFluidPropertiesMaterials()
     240             : {
     241          19 :   const std::string class_name = "FluidPropertiesGasMixMaterial";
     242          19 :   InputParameters params = _factory.getValidParams(class_name);
     243          38 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     244          57 :   params.set<std::vector<VariableName>>("xirhoA") = {THM::XIRHOA};
     245          57 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     246          57 :   params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     247          57 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     248          57 :   params.set<std::vector<VariableName>>("area") = {THM::AREA};
     249          19 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     250          38 :   _sim.addMaterial(class_name, genName(_comp_name, "fp_mat"), params);
     251          38 : }
     252             : 
     253             : void
     254          19 : FlowModelGasMix::addNumericalFluxUserObject()
     255             : {
     256          19 :   const std::string class_name = "NumericalFluxGasMixHLLC";
     257          19 :   InputParameters params = _factory.getValidParams(class_name);
     258          19 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     259          38 :   params.set<MooseEnum>("emit_on_nan") = "none";
     260          95 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
     261          19 :   _sim.addUserObject(class_name, _numerical_flux_name, params);
     262          57 : }
     263             : 
     264             : void
     265          19 : FlowModelGasMix::addSlopeReconstructionMaterial()
     266             : {
     267          19 :   const std::string class_name = "SlopeReconstructionGasMixMaterial";
     268          19 :   InputParameters params = _factory.getValidParams(class_name);
     269          19 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     270          38 :   params.set<MooseEnum>("scheme") = _rdg_slope_reconstruction;
     271          57 :   params.set<std::vector<VariableName>>("A_elem") = {THM::AREA};
     272          57 :   params.set<std::vector<VariableName>>("A_linear") = {THM::AREA_LINEAR};
     273          57 :   params.set<std::vector<VariableName>>("xirhoA") = {THM::XIRHOA};
     274          57 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     275          57 :   params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     276          57 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     277          19 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     278          19 :   params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     279          38 :   _sim.addMaterial(class_name, genName(_comp_name, "slope_mat"), params);
     280          38 : }
     281             : 
     282             : void
     283          19 : FlowModelGasMix::addRDGAdvectionDGKernels()
     284             : {
     285          95 :   const std::vector<NonlinearVariableName> vars{THM::XIRHOA, THM::RHOA, THM::RHOUA, THM::RHOEA};
     286             : 
     287          95 :   for (const auto & var : vars)
     288             :   {
     289          76 :     const std::string class_name = "NumericalFluxGasMixDGKernel";
     290          76 :     InputParameters params = _factory.getValidParams(class_name);
     291          76 :     params.set<NonlinearVariableName>("variable") = var;
     292         152 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     293         228 :     params.set<std::vector<VariableName>>("A_linear") = {THM::AREA_LINEAR};
     294         228 :     params.set<std::vector<VariableName>>("xirhoA") = {THM::XIRHOA};
     295         228 :     params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     296         228 :     params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     297         228 :     params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     298          76 :     params.set<UserObjectName>("numerical_flux") = _numerical_flux_name;
     299          76 :     params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     300         152 :     _sim.addDGKernel(class_name, genName(_comp_name, "advection:" + var), params);
     301          76 :   }
     302          19 : }