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 "FlowModel1PhaseBase.h"
      11             : #include "FlowChannel1PhaseBase.h"
      12             : #include "THMNames.h"
      13             : 
      14             : InputParameters
      15        4284 : FlowModel1PhaseBase::validParams()
      16             : {
      17        4284 :   InputParameters params = FlowModel::validParams();
      18        8568 :   params.addRequiredParam<UserObjectName>("numerical_flux", "Numerical flux user object name");
      19        8568 :   params.addRequiredParam<MooseEnum>("rdg_slope_reconstruction",
      20             :                                      "Slope reconstruction type for rDG");
      21        4284 :   return params;
      22           0 : }
      23             : 
      24        2142 : FlowModel1PhaseBase::FlowModel1PhaseBase(const InputParameters & params)
      25             :   : FlowModel(params),
      26        2142 :     _rdg_slope_reconstruction(params.get<MooseEnum>("rdg_slope_reconstruction")),
      27        4284 :     _numerical_flux_name(params.get<UserObjectName>("numerical_flux"))
      28             : {
      29        2142 : }
      30             : 
      31             : void
      32        2046 : FlowModel1PhaseBase::addVariables()
      33             : {
      34        2046 :   FlowModel::addCommonVariables();
      35             : 
      36        2046 :   const std::vector<SubdomainName> & subdomains = _flow_channel.getSubdomainNames();
      37             : 
      38             :   // Nonlinear variables
      39        2046 :   _sim.addSimVariable(true, THM::RHOA, _fe_type, subdomains, getScalingFactorRhoA());
      40        2046 :   _sim.addSimVariable(true, THM::RHOUA, _fe_type, subdomains, getScalingFactorRhoUA());
      41        2046 :   _sim.addSimVariable(true, THM::RHOEA, _fe_type, subdomains, getScalingFactorRhoEA());
      42             : 
      43             :   // Auxiliary variables
      44        2046 :   _sim.addSimVariable(false, THM::DENSITY, _fe_type, subdomains);
      45        2046 :   if (_output_vector_velocity)
      46             :   {
      47        1524 :     _sim.addSimVariable(false, THM::VELOCITY_X, _fe_type, subdomains);
      48        1524 :     _sim.addSimVariable(false, THM::VELOCITY_Y, _fe_type, subdomains);
      49        3048 :     _sim.addSimVariable(false, THM::VELOCITY_Z, _fe_type, subdomains);
      50             :   }
      51             :   else
      52        1044 :     _sim.addSimVariable(false, THM::VELOCITY, _fe_type, subdomains);
      53        2046 :   _sim.addSimVariable(false, THM::PRESSURE, _fe_type, subdomains);
      54        2046 :   _sim.addSimVariable(false, THM::SPECIFIC_VOLUME, _fe_type, subdomains);
      55        2046 :   _sim.addSimVariable(false, THM::SPECIFIC_INTERNAL_ENERGY, _fe_type, subdomains);
      56        2046 :   _sim.addSimVariable(false, THM::TEMPERATURE, _fe_type, subdomains);
      57        2046 :   _sim.addSimVariable(false, THM::SPECIFIC_TOTAL_ENTHALPY, _fe_type, subdomains);
      58             : 
      59        2046 :   _solution_vars = solutionVariableNames();
      60        2046 :   _derivative_vars = solutionVariableNames();
      61        2046 : }
      62             : 
      63             : void
      64        2046 : FlowModel1PhaseBase::addInitialConditions()
      65             : {
      66        2046 :   FlowModel::addCommonInitialConditions();
      67             : 
      68        2046 :   if (ICParametersAreValid())
      69             :   {
      70        2000 :     addRhoAIC();
      71        2000 :     addRhoUAIC();
      72        2000 :     addRhoEAIC();
      73             : 
      74        6000 :     addFunctionIC(THM::PRESSURE, _flow_channel.getParam<FunctionName>("initial_p"));
      75        6000 :     addFunctionIC(THM::TEMPERATURE, _flow_channel.getParam<FunctionName>("initial_T"));
      76        2000 :     addVelocityIC();
      77        2000 :     addDensityIC();
      78        2000 :     addSpecificVolumeIC();
      79        2000 :     addSpecificInternalEnergyIC();
      80        2000 :     addSpecificTotalEnthalpyIC();
      81             :   }
      82        2046 : }
      83             : 
      84             : bool
      85        2055 : FlowModel1PhaseBase::ICParametersAreValid() const
      86             : {
      87             :   const auto & flow_channel_1phase_base =
      88        2055 :       dynamic_cast<const FlowChannel1PhaseBase &>(_flow_channel);
      89             : 
      90        8100 :   for (const auto & param : flow_channel_1phase_base.ICParameters())
      91        6091 :     if (!_flow_channel.isParamValid(param))
      92        2055 :       return false;
      93             : 
      94        2009 :   return true;
      95             : }
      96             : 
      97             : void
      98        4491 : FlowModel1PhaseBase::addFunctionIC(const VariableName & var_name,
      99             :                                    const FunctionName & function_name)
     100             : {
     101        4491 :   const std::string class_name = "FunctionIC";
     102        4491 :   InputParameters params = _factory.getValidParams(class_name);
     103        4491 :   params.set<VariableName>("variable") = var_name;
     104        4491 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     105        4491 :   params.set<FunctionName>("function") = function_name;
     106        8982 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, var_name + "_ic"), params);
     107        8982 : }
     108             : 
     109             : void
     110        2000 : FlowModel1PhaseBase::addRhoAIC()
     111             : {
     112        2000 :   const std::string class_name = "VariableProductIC";
     113        2000 :   InputParameters params = _factory.getValidParams(class_name);
     114        4000 :   params.set<VariableName>("variable") = THM::RHOA;
     115        4000 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     116        8000 :   params.set<std::vector<VariableName>>("values") = {THM::DENSITY, THM::AREA};
     117        4000 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rhoA_ic"), params);
     118        4000 : }
     119             : 
     120             : void
     121        2000 : FlowModel1PhaseBase::addRhoUAIC()
     122             : {
     123        2000 :   const std::string class_name = "VariableFunctionProductIC";
     124        2000 :   InputParameters params = _factory.getValidParams(class_name);
     125        4000 :   params.set<VariableName>("variable") = THM::RHOUA;
     126        4000 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     127        6000 :   params.set<std::vector<VariableName>>("var") = {THM::RHOA};
     128        6000 :   params.set<FunctionName>("fn") = _flow_channel.getParam<FunctionName>("initial_vel");
     129        4000 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rhouA_ic"), params);
     130        4000 : }
     131             : 
     132             : void
     133        2000 : FlowModel1PhaseBase::addVelocityIC()
     134             : {
     135        2000 :   if (_output_vector_velocity)
     136             :   {
     137        6072 :     std::vector<VariableName> var_name = {THM::VELOCITY_X, THM::VELOCITY_Y, THM::VELOCITY_Z};
     138        6072 :     for (const auto i : make_range(Moose::dim))
     139             :     {
     140        4554 :       const std::string class_name = "VectorVelocityIC";
     141        4554 :       InputParameters params = _factory.getValidParams(class_name);
     142        4554 :       params.set<VariableName>("variable") = var_name[i];
     143       13662 :       params.set<FunctionName>("vel_fn") = _flow_channel.getParam<FunctionName>("initial_vel");
     144        4554 :       params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     145        4554 :       params.set<unsigned int>("component") = i;
     146        9108 :       _sim.addSimInitialCondition(class_name, genName(_comp_name, "vel_ic", i), params);
     147        4554 :     }
     148        1518 :   }
     149             :   else
     150        1446 :     addFunctionIC(THM::VELOCITY, _flow_channel.getParam<FunctionName>("initial_vel"));
     151        2000 : }
     152             : 
     153             : void
     154        2000 : FlowModel1PhaseBase::addSpecificVolumeIC()
     155             : {
     156        2000 :   const std::string class_name = "SpecificVolumeIC";
     157        2000 :   InputParameters params = _factory.getValidParams(class_name);
     158        4000 :   params.set<VariableName>("variable") = THM::SPECIFIC_VOLUME;
     159        4000 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     160        6000 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     161        6000 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     162        4000 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "v_ic"), params);
     163        4000 : }
     164             : 
     165             : void
     166        2000 : FlowModel1PhaseBase::addSpecificInternalEnergyIC()
     167             : {
     168        2000 :   const std::string class_name = "SpecificInternalEnergyIC";
     169        2000 :   InputParameters params = _factory.getValidParams(class_name);
     170        4000 :   params.set<VariableName>("variable") = THM::SPECIFIC_INTERNAL_ENERGY;
     171        4000 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     172        6000 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     173        6000 :   params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     174        6000 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     175        4000 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "e_ic"), params);
     176        4000 : }
     177             : 
     178             : void
     179        2000 : FlowModel1PhaseBase::addSpecificTotalEnthalpyIC()
     180             : {
     181        2000 :   const std::string class_name = "SpecificTotalEnthalpyIC";
     182        2000 :   InputParameters params = _factory.getValidParams(class_name);
     183        4000 :   params.set<VariableName>("variable") = THM::SPECIFIC_TOTAL_ENTHALPY;
     184        4000 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     185        6000 :   params.set<std::vector<VariableName>>("p") = {THM::PRESSURE};
     186        6000 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     187        6000 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     188        6000 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     189        4000 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "H_ic"), params);
     190        4000 : }
     191             : 
     192             : void
     193        2046 : FlowModel1PhaseBase::addMooseObjects()
     194             : {
     195        2046 :   FlowModel::addCommonMooseObjects();
     196             : 
     197        2046 :   addKernels();
     198        2046 :   addDGKernels();
     199        2046 :   addFunctorMaterials();
     200        2046 :   addAuxKernels();
     201        2046 :   addFluidPropertiesMaterials();
     202        2046 :   addNumericalFluxUserObject();
     203        2046 :   addRDGMooseObjects();
     204        2046 :   addPostprocessors();
     205        2046 : }
     206             : 
     207             : void
     208        2046 : FlowModel1PhaseBase::addKernels()
     209             : {
     210             :   // Mass equation
     211        4092 :   addTimeDerivativeKernelIfTransient(THM::RHOA);
     212             : 
     213             :   // Momentum equation
     214        2046 :   addTimeDerivativeKernelIfTransient(THM::RHOUA);
     215        2046 :   addMomentumAreaGradientKernel();
     216        2046 :   addMomentumFrictionKernel();
     217        2046 :   addMomentumGravityKernel();
     218             : 
     219             :   // Energy equation
     220        2046 :   addTimeDerivativeKernelIfTransient(THM::RHOEA);
     221        2046 :   addEnergyGravityKernel();
     222        2046 : }
     223             : 
     224             : void
     225        6165 : FlowModel1PhaseBase::addTimeDerivativeKernelIfTransient(const VariableName & var_name)
     226             : {
     227        6165 :   if (_flow_channel.problemIsTransient())
     228             :   {
     229        6138 :     const std::string class_name = "ADTimeDerivative";
     230        6138 :     InputParameters params = _factory.getValidParams(class_name);
     231       12276 :     params.set<NonlinearVariableName>("variable") = var_name;
     232        6138 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     233       12276 :     _sim.addKernel(class_name, genName(_comp_name, var_name + "_td"), params);
     234        6138 :   }
     235        6165 : }
     236             : 
     237             : void
     238        2046 : FlowModel1PhaseBase::addMomentumAreaGradientKernel()
     239             : {
     240        2046 :   const std::string class_name = "ADOneD3EqnMomentumAreaGradient";
     241        2046 :   InputParameters params = _factory.getValidParams(class_name);
     242        4092 :   params.set<NonlinearVariableName>("variable") = THM::RHOUA;
     243        4092 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     244        6138 :   params.set<std::vector<VariableName>>("A") = {THM::AREA_LINEAR};
     245        4092 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     246        4092 :   params.set<MaterialPropertyName>("p") = THM::PRESSURE;
     247        4092 :   _sim.addKernel(class_name, genName(_comp_name, "mom_area_grad"), params);
     248        4092 : }
     249             : 
     250             : void
     251        2046 : FlowModel1PhaseBase::addMomentumFrictionKernel()
     252             : {
     253        2046 :   const std::string class_name = "ADOneD3EqnMomentumFriction";
     254        2046 :   InputParameters params = _factory.getValidParams(class_name);
     255        4092 :   params.set<NonlinearVariableName>("variable") = THM::RHOUA;
     256        4092 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     257        6138 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     258        4092 :   params.set<MaterialPropertyName>("D_h") = {THM::HYDRAULIC_DIAMETER};
     259        4092 :   params.set<MaterialPropertyName>("rho") = THM::DENSITY;
     260        4092 :   params.set<MaterialPropertyName>("vel") = THM::VELOCITY;
     261        4092 :   params.set<MaterialPropertyName>("f_D") = THM::FRICTION_FACTOR_DARCY;
     262        4092 :   _sim.addKernel(class_name, genName(_comp_name, "mom_friction"), params);
     263        4092 : }
     264             : 
     265             : void
     266        2046 : FlowModel1PhaseBase::addMomentumGravityKernel()
     267             : {
     268        2046 :   const std::string class_name = "ADOneD3EqnMomentumGravity";
     269        2046 :   InputParameters params = _factory.getValidParams(class_name);
     270        4092 :   params.set<NonlinearVariableName>("variable") = THM::RHOUA;
     271        4092 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     272        6138 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     273        4092 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     274        4092 :   params.set<MaterialPropertyName>("rho") = THM::DENSITY;
     275        2046 :   params.set<RealVectorValue>("gravity_vector") = _gravity_vector;
     276        4092 :   _sim.addKernel(class_name, genName(_comp_name, "mom_gravity"), params);
     277        4092 : }
     278             : 
     279             : void
     280        2046 : FlowModel1PhaseBase::addEnergyGravityKernel()
     281             : {
     282        2046 :   const std::string class_name = "ADOneD3EqnEnergyGravity";
     283        2046 :   InputParameters params = _factory.getValidParams(class_name);
     284        4092 :   params.set<NonlinearVariableName>("variable") = THM::RHOEA;
     285        4092 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     286        6138 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     287        4092 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     288        4092 :   params.set<MaterialPropertyName>("rho") = THM::DENSITY;
     289        4092 :   params.set<MaterialPropertyName>("vel") = THM::VELOCITY;
     290        2046 :   params.set<RealVectorValue>("gravity_vector") = _gravity_vector;
     291        4092 :   _sim.addKernel(class_name, genName(_comp_name, "energy_gravity"), params);
     292        4092 : }
     293             : 
     294             : void
     295        2046 : FlowModel1PhaseBase::addDGKernels()
     296             : {
     297        4092 :   if (_flow_channel.getParam<bool>("enable_heat_conduction"))
     298           9 :     addHeatConductionDGKernel();
     299        2046 : }
     300             : 
     301             : void
     302           9 : FlowModel1PhaseBase::addHeatConductionDGKernel()
     303             : {
     304           9 :   const std::string class_name = "HeatConduction3EqnDGKernel";
     305           9 :   InputParameters params = _factory.getValidParams(class_name);
     306          18 :   params.set<NonlinearVariableName>("variable") = THM::RHOEA;
     307          18 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     308          18 :   params.set<MaterialPropertyName>("k") = THM::THERMAL_CONDUCTIVITY;
     309          18 :   params.set<MaterialPropertyName>("T") = THM::TEMPERATURE;
     310          18 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     311          27 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     312          18 :   _sim.addDGKernel(class_name, genName(name(), "heat_cond"), params);
     313          18 : }
     314             : 
     315             : void
     316        2046 : FlowModel1PhaseBase::addAuxKernels()
     317             : {
     318        2046 :   addPressureAux();
     319        2046 :   addTemperatureAux();
     320        2046 :   addVelocityAux();
     321        2046 :   addDensityAux();
     322        2046 :   addSpecificVolumeAux();
     323        2046 :   addSpecificInternalEnergyAux();
     324        2046 :   addSpecificTotalEnthalpyAux();
     325        2046 : }
     326             : 
     327             : void
     328        2046 : FlowModel1PhaseBase::addVelocityAux()
     329             : {
     330        2046 :   if (_output_vector_velocity)
     331             :   {
     332        6096 :     std::vector<AuxVariableName> var_names = {THM::VELOCITY_X, THM::VELOCITY_Y, THM::VELOCITY_Z};
     333        6096 :     for (const auto i : make_range(Moose::dim))
     334             :     {
     335        4572 :       const std::string class_name = "ADVectorVelocityComponentAux";
     336        4572 :       InputParameters params = _factory.getValidParams(class_name);
     337        4572 :       params.set<AuxVariableName>("variable") = var_names[i];
     338        9144 :       params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     339       13716 :       params.set<std::vector<VariableName>>("arhoA") = {THM::RHOA};
     340       13716 :       params.set<std::vector<VariableName>>("arhouA") = {THM::RHOUA};
     341        9144 :       params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     342        4572 :       params.set<unsigned int>("component") = i;
     343       18288 :       params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     344        4572 :       _sim.addAuxKernel(class_name, genName(_comp_name, i, "vel_vec"), params);
     345        4572 :     }
     346        1524 :   }
     347             :   else
     348             :   {
     349         522 :     const std::string class_name = "QuotientAux";
     350         522 :     InputParameters params = _factory.getValidParams(class_name);
     351        1044 :     params.set<AuxVariableName>("variable") = THM::VELOCITY;
     352        1044 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     353        1566 :     params.set<std::vector<VariableName>>("numerator") = {THM::RHOUA};
     354        1566 :     params.set<std::vector<VariableName>>("denominator") = {THM::RHOA};
     355        2088 :     params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     356        1044 :     _sim.addAuxKernel(class_name, genName(_comp_name, "vel"), params);
     357         522 :   }
     358        7140 : }
     359             : 
     360             : void
     361        2046 : FlowModel1PhaseBase::addDensityAux()
     362             : {
     363        2046 :   const std::string class_name = "QuotientAux";
     364        2046 :   InputParameters params = _factory.getValidParams(class_name);
     365        4092 :   params.set<AuxVariableName>("variable") = THM::DENSITY;
     366        4092 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     367        6138 :   params.set<std::vector<VariableName>>("numerator") = {THM::RHOA};
     368        6138 :   params.set<std::vector<VariableName>>("denominator") = {THM::AREA};
     369        8184 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     370        4092 :   _sim.addAuxKernel(class_name, genName(_comp_name, "rho_aux"), params);
     371        6138 : }
     372             : 
     373             : void
     374        2046 : FlowModel1PhaseBase::addSpecificVolumeAux()
     375             : {
     376        2046 :   const std::string class_name = "THMSpecificVolumeAux";
     377        2046 :   InputParameters params = _factory.getValidParams(class_name);
     378        4092 :   params.set<AuxVariableName>("variable") = THM::SPECIFIC_VOLUME;
     379        4092 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     380        6138 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     381        6138 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     382        8184 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     383        4092 :   _sim.addAuxKernel(class_name, genName(_comp_name, "v_aux"), params);
     384        6138 : }
     385             : 
     386             : void
     387        2046 : FlowModel1PhaseBase::addSpecificInternalEnergyAux()
     388             : {
     389        2046 :   const std::string class_name = "THMSpecificInternalEnergyAux";
     390        2046 :   InputParameters params = _factory.getValidParams(class_name);
     391        4092 :   params.set<AuxVariableName>("variable") = THM::SPECIFIC_INTERNAL_ENERGY;
     392        4092 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     393        6138 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     394        6138 :   params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     395        6138 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     396        8184 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     397        4092 :   _sim.addAuxKernel(class_name, genName(_comp_name, "e_aux"), params);
     398        6138 : }
     399             : 
     400             : void
     401        2046 : FlowModel1PhaseBase::addSpecificTotalEnthalpyAux()
     402             : {
     403        2046 :   const std::string class_name = "SpecificTotalEnthalpyAux";
     404        2046 :   InputParameters params = _factory.getValidParams(class_name);
     405        4092 :   params.set<AuxVariableName>("variable") = THM::SPECIFIC_TOTAL_ENTHALPY;
     406        4092 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     407        6138 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     408        6138 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     409        6138 :   params.set<std::vector<VariableName>>("p") = {THM::PRESSURE};
     410        6138 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     411        8184 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     412        4092 :   _sim.addAuxKernel(class_name, genName(_comp_name, "H_auxkernel"), params);
     413        6138 : }
     414             : 
     415             : void
     416        2046 : FlowModel1PhaseBase::addRDGMooseObjects()
     417             : {
     418        2046 :   addSlopeReconstructionMaterial();
     419        2046 :   addRDGAdvectionDGKernels();
     420        2046 : }