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        8362 : FlowModel1PhaseBase::validParams()
      16             : {
      17        8362 :   InputParameters params = FlowModel::validParams();
      18       16724 :   params.addRequiredParam<UserObjectName>("numerical_flux", "Numerical flux user object name");
      19       16724 :   params.addRequiredParam<MooseEnum>("rdg_slope_reconstruction",
      20             :                                      "Slope reconstruction type for rDG");
      21       16724 :   params.addRequiredParam<FunctionName>("A_function", "Cross-sectional area function");
      22       16724 :   params.addRequiredParam<Real>("p_ref", "Reference pressure");
      23       16724 :   params.addRequiredParam<Real>("T_ref", "Reference temperature");
      24       16724 :   params.addRequiredParam<Real>("vel_ref", "Reference velocity");
      25        8362 :   return params;
      26           0 : }
      27             : 
      28        4181 : FlowModel1PhaseBase::FlowModel1PhaseBase(const InputParameters & params)
      29             :   : FlowModel(params),
      30        4181 :     _rdg_slope_reconstruction(params.get<MooseEnum>("rdg_slope_reconstruction")),
      31        4181 :     _numerical_flux_name(params.get<UserObjectName>("numerical_flux")),
      32        8362 :     _p_ref(getParam<Real>("p_ref")),
      33        8362 :     _T_ref(getParam<Real>("T_ref")),
      34        8362 :     _vel_ref(getParam<Real>("vel_ref")),
      35        4181 :     _start_point(_flow_channel.getStartPoint()),
      36             :     _end_point(_flow_channel.getEndPoint()),
      37        4181 :     _mid_point(0.5 * (_start_point + _end_point))
      38             : {
      39        4181 : }
      40             : 
      41             : void
      42        4067 : FlowModel1PhaseBase::addVariables()
      43             : {
      44        4067 :   FlowModel::addCommonVariables();
      45             : 
      46        4067 :   const std::vector<SubdomainName> & subdomains = _flow_channel.getSubdomainNames();
      47             : 
      48             :   // Nonlinear variables
      49        4067 :   _sim.addSimVariable(true, THM::RHOA, _fe_type, subdomains, getScalingFactorRhoA());
      50        4067 :   _sim.addSimVariable(true, THM::RHOUA, _fe_type, subdomains, getScalingFactorRhoUA());
      51        4067 :   _sim.addSimVariable(true, THM::RHOEA, _fe_type, subdomains, getScalingFactorRhoEA());
      52             : 
      53             :   // Auxiliary variables
      54        4067 :   _sim.addSimVariable(false, THM::DENSITY, _fe_type, subdomains);
      55        4067 :   if (_output_vector_velocity)
      56             :   {
      57        3047 :     _sim.addSimVariable(false, THM::VELOCITY_X, _fe_type, subdomains);
      58        3047 :     _sim.addSimVariable(false, THM::VELOCITY_Y, _fe_type, subdomains);
      59        6094 :     _sim.addSimVariable(false, THM::VELOCITY_Z, _fe_type, subdomains);
      60             :   }
      61             :   else
      62        2040 :     _sim.addSimVariable(false, THM::VELOCITY, _fe_type, subdomains);
      63        4067 :   _sim.addSimVariable(false, THM::PRESSURE, _fe_type, subdomains);
      64        4067 :   _sim.addSimVariable(false, THM::SPECIFIC_VOLUME, _fe_type, subdomains);
      65        4067 :   _sim.addSimVariable(false, THM::SPECIFIC_INTERNAL_ENERGY, _fe_type, subdomains);
      66        4067 :   _sim.addSimVariable(false, THM::TEMPERATURE, _fe_type, subdomains);
      67        4067 :   _sim.addSimVariable(false, THM::SPECIFIC_TOTAL_ENTHALPY, _fe_type, subdomains);
      68             : 
      69        4067 :   _solution_vars = solutionVariableNames();
      70        4067 :   _derivative_vars = solutionVariableNames();
      71        4067 : }
      72             : 
      73             : void
      74        4067 : FlowModel1PhaseBase::addInitialConditions()
      75             : {
      76        4067 :   FlowModel::addCommonInitialConditions();
      77             : 
      78        4067 :   if (ICParametersAreValid())
      79             :   {
      80        4005 :     addRhoAIC();
      81        4005 :     addRhoUAIC();
      82        4005 :     addRhoEAIC();
      83             : 
      84       12015 :     addFunctionIC(THM::PRESSURE, _flow_channel.getParam<FunctionName>("initial_p"));
      85       12015 :     addFunctionIC(THM::TEMPERATURE, _flow_channel.getParam<FunctionName>("initial_T"));
      86        4005 :     addVelocityIC();
      87        4005 :     addDensityIC();
      88        4005 :     addSpecificVolumeIC();
      89        4005 :     addSpecificInternalEnergyIC();
      90        4005 :     addSpecificTotalEnthalpyIC();
      91             :   }
      92        4067 : }
      93             : 
      94             : bool
      95        4086 : FlowModel1PhaseBase::ICParametersAreValid() const
      96             : {
      97             :   const auto & flow_channel_1phase_base =
      98        4086 :       dynamic_cast<const FlowChannel1PhaseBase &>(_flow_channel);
      99             : 
     100       16196 :   for (const auto & param : flow_channel_1phase_base.ICParameters())
     101       12172 :     if (!_flow_channel.isParamValid(param))
     102        4086 :       return false;
     103             : 
     104        4024 :   return true;
     105             : }
     106             : 
     107             : void
     108        8993 : FlowModel1PhaseBase::addFunctionIC(const VariableName & var_name,
     109             :                                    const FunctionName & function_name)
     110             : {
     111        8993 :   const std::string class_name = "FunctionIC";
     112        8993 :   InputParameters params = _factory.getValidParams(class_name);
     113        8993 :   params.set<VariableName>("variable") = var_name;
     114        8993 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     115        8993 :   params.set<FunctionName>("function") = function_name;
     116       17986 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, var_name + "_ic"), params);
     117       17986 : }
     118             : 
     119             : void
     120        4005 : FlowModel1PhaseBase::addRhoAIC()
     121             : {
     122        4005 :   const std::string class_name = "VariableProductIC";
     123        4005 :   InputParameters params = _factory.getValidParams(class_name);
     124        8010 :   params.set<VariableName>("variable") = THM::RHOA;
     125        8010 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     126       16020 :   params.set<std::vector<VariableName>>("values") = {THM::DENSITY, THM::AREA};
     127        8010 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rhoA_ic"), params);
     128        8010 : }
     129             : 
     130             : void
     131        4005 : FlowModel1PhaseBase::addRhoUAIC()
     132             : {
     133        4005 :   const std::string class_name = "VariableFunctionProductIC";
     134        4005 :   InputParameters params = _factory.getValidParams(class_name);
     135        8010 :   params.set<VariableName>("variable") = THM::RHOUA;
     136        8010 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     137       12015 :   params.set<std::vector<VariableName>>("var") = {THM::RHOA};
     138       12015 :   params.set<FunctionName>("fn") = _flow_channel.getParam<FunctionName>("initial_vel");
     139        8010 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rhouA_ic"), params);
     140        8010 : }
     141             : 
     142             : void
     143        4005 : FlowModel1PhaseBase::addVelocityIC()
     144             : {
     145        4005 :   if (_output_vector_velocity)
     146             :   {
     147       12164 :     std::vector<VariableName> var_name = {THM::VELOCITY_X, THM::VELOCITY_Y, THM::VELOCITY_Z};
     148       12164 :     for (const auto i : make_range(Moose::dim))
     149             :     {
     150        9123 :       const std::string class_name = "VectorVelocityIC";
     151        9123 :       InputParameters params = _factory.getValidParams(class_name);
     152        9123 :       params.set<VariableName>("variable") = var_name[i];
     153       27369 :       params.set<FunctionName>("vel_fn") = _flow_channel.getParam<FunctionName>("initial_vel");
     154        9123 :       params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     155        9123 :       params.set<unsigned int>("component") = i;
     156       18246 :       _sim.addSimInitialCondition(class_name, genName(_comp_name, "vel_ic", i), params);
     157        9123 :     }
     158        3041 :   }
     159             :   else
     160        2892 :     addFunctionIC(THM::VELOCITY, _flow_channel.getParam<FunctionName>("initial_vel"));
     161        4005 : }
     162             : 
     163             : void
     164        4005 : FlowModel1PhaseBase::addSpecificVolumeIC()
     165             : {
     166        4005 :   const std::string class_name = "SpecificVolumeIC";
     167        4005 :   InputParameters params = _factory.getValidParams(class_name);
     168        8010 :   params.set<VariableName>("variable") = THM::SPECIFIC_VOLUME;
     169        8010 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     170       12015 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     171       12015 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     172        8010 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "v_ic"), params);
     173        8010 : }
     174             : 
     175             : void
     176        4005 : FlowModel1PhaseBase::addSpecificInternalEnergyIC()
     177             : {
     178        4005 :   const std::string class_name = "SpecificInternalEnergyIC";
     179        4005 :   InputParameters params = _factory.getValidParams(class_name);
     180        8010 :   params.set<VariableName>("variable") = THM::SPECIFIC_INTERNAL_ENERGY;
     181        8010 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     182       12015 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     183       12015 :   params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     184       12015 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     185        8010 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "e_ic"), params);
     186        8010 : }
     187             : 
     188             : void
     189        4005 : FlowModel1PhaseBase::addSpecificTotalEnthalpyIC()
     190             : {
     191        4005 :   const std::string class_name = "SpecificTotalEnthalpyIC";
     192        4005 :   InputParameters params = _factory.getValidParams(class_name);
     193        8010 :   params.set<VariableName>("variable") = THM::SPECIFIC_TOTAL_ENTHALPY;
     194        8010 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     195       12015 :   params.set<std::vector<VariableName>>("p") = {THM::PRESSURE};
     196       12015 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     197       12015 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     198       12015 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     199        8010 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "H_ic"), params);
     200        8010 : }
     201             : 
     202             : void
     203        4067 : FlowModel1PhaseBase::addMooseObjects()
     204             : {
     205        4067 :   FlowModel::addCommonMooseObjects();
     206             : 
     207        4067 :   addKernels();
     208        4067 :   addDGKernels();
     209        4067 :   addFunctorMaterials();
     210        4067 :   addAuxKernels();
     211        4067 :   addFluidPropertiesMaterials();
     212        4067 :   addNumericalFluxUserObject();
     213        4067 :   addRDGMooseObjects();
     214        4067 :   addPostprocessors();
     215        4067 : }
     216             : 
     217             : void
     218        4067 : FlowModel1PhaseBase::addKernels()
     219             : {
     220             :   // Mass equation
     221        8134 :   addTimeDerivativeKernelIfTransient(THM::RHOA);
     222             : 
     223             :   // Momentum equation
     224        4067 :   addTimeDerivativeKernelIfTransient(THM::RHOUA);
     225        4067 :   addMomentumAreaGradientKernel();
     226        4067 :   addMomentumFrictionKernel();
     227        4067 :   addMomentumGravityKernel();
     228             : 
     229             :   // Energy equation
     230        4067 :   addTimeDerivativeKernelIfTransient(THM::RHOEA);
     231        4067 :   addEnergyGravityKernel();
     232        4067 : }
     233             : 
     234             : void
     235       12220 : FlowModel1PhaseBase::addTimeDerivativeKernelIfTransient(const VariableName & var_name)
     236             : {
     237       12220 :   if (_flow_channel.problemIsTransient())
     238             :   {
     239       12163 :     const std::string class_name = "ADTimeDerivative";
     240       12163 :     InputParameters params = _factory.getValidParams(class_name);
     241       24326 :     params.set<NonlinearVariableName>("variable") = var_name;
     242       12163 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     243       24326 :     _sim.addKernel(class_name, genName(_comp_name, var_name + "_td"), params);
     244       12163 :   }
     245       12220 : }
     246             : 
     247             : void
     248        4067 : FlowModel1PhaseBase::addMomentumAreaGradientKernel()
     249             : {
     250        4067 :   const std::string class_name = "ADOneD3EqnMomentumAreaGradient";
     251        4067 :   InputParameters params = _factory.getValidParams(class_name);
     252        8134 :   params.set<NonlinearVariableName>("variable") = THM::RHOUA;
     253        8134 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     254       12201 :   params.set<std::vector<VariableName>>("A") = {THM::AREA_LINEAR};
     255        8134 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     256        8134 :   params.set<MaterialPropertyName>("p") = THM::PRESSURE;
     257        8134 :   _sim.addKernel(class_name, genName(_comp_name, "mom_area_grad"), params);
     258        8134 : }
     259             : 
     260             : void
     261        4067 : FlowModel1PhaseBase::addMomentumFrictionKernel()
     262             : {
     263        4067 :   const std::string class_name = "ADOneD3EqnMomentumFriction";
     264        4067 :   InputParameters params = _factory.getValidParams(class_name);
     265        8134 :   params.set<NonlinearVariableName>("variable") = THM::RHOUA;
     266        8134 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     267       12201 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     268        8134 :   params.set<MaterialPropertyName>("D_h") = {THM::HYDRAULIC_DIAMETER};
     269        8134 :   params.set<MaterialPropertyName>("rho") = THM::DENSITY;
     270        8134 :   params.set<MaterialPropertyName>("vel") = THM::VELOCITY;
     271        8134 :   params.set<MaterialPropertyName>("f_D") = THM::FRICTION_FACTOR_DARCY;
     272        8134 :   _sim.addKernel(class_name, genName(_comp_name, "mom_friction"), params);
     273        8134 : }
     274             : 
     275             : void
     276        4067 : FlowModel1PhaseBase::addMomentumGravityKernel()
     277             : {
     278        4067 :   const std::string class_name = "ADOneD3EqnMomentumGravity";
     279        4067 :   InputParameters params = _factory.getValidParams(class_name);
     280        8134 :   params.set<NonlinearVariableName>("variable") = THM::RHOUA;
     281        8134 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     282       12201 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     283        8134 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     284        8134 :   params.set<MaterialPropertyName>("rho") = THM::DENSITY;
     285        4067 :   params.set<RealVectorValue>("gravity_vector") = _gravity_vector;
     286        8134 :   _sim.addKernel(class_name, genName(_comp_name, "mom_gravity"), params);
     287        8134 : }
     288             : 
     289             : void
     290        4067 : FlowModel1PhaseBase::addEnergyGravityKernel()
     291             : {
     292        4067 :   const std::string class_name = "ADOneD3EqnEnergyGravity";
     293        4067 :   InputParameters params = _factory.getValidParams(class_name);
     294        8134 :   params.set<NonlinearVariableName>("variable") = THM::RHOEA;
     295        8134 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     296       12201 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     297        8134 :   params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     298        8134 :   params.set<MaterialPropertyName>("rho") = THM::DENSITY;
     299        8134 :   params.set<MaterialPropertyName>("vel") = THM::VELOCITY;
     300        4067 :   params.set<RealVectorValue>("gravity_vector") = _gravity_vector;
     301        8134 :   _sim.addKernel(class_name, genName(_comp_name, "energy_gravity"), params);
     302        8134 : }
     303             : 
     304             : void
     305        4067 : FlowModel1PhaseBase::addDGKernels()
     306             : {
     307        4067 : }
     308             : 
     309             : void
     310        4067 : FlowModel1PhaseBase::addAuxKernels()
     311             : {
     312        4067 :   addPressureAux();
     313        4067 :   addTemperatureAux();
     314        4067 :   addVelocityAux();
     315        4067 :   addDensityAux();
     316        4067 :   addSpecificVolumeAux();
     317        4067 :   addSpecificInternalEnergyAux();
     318        4067 :   addSpecificTotalEnthalpyAux();
     319        4067 : }
     320             : 
     321             : void
     322        4067 : FlowModel1PhaseBase::addVelocityAux()
     323             : {
     324        4067 :   if (_output_vector_velocity)
     325             :   {
     326       12188 :     std::vector<AuxVariableName> var_names = {THM::VELOCITY_X, THM::VELOCITY_Y, THM::VELOCITY_Z};
     327       12188 :     for (const auto i : make_range(Moose::dim))
     328             :     {
     329        9141 :       const std::string class_name = "ADVectorVelocityComponentAux";
     330        9141 :       InputParameters params = _factory.getValidParams(class_name);
     331        9141 :       params.set<AuxVariableName>("variable") = var_names[i];
     332       18282 :       params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     333       27423 :       params.set<std::vector<VariableName>>("arhoA") = {THM::RHOA};
     334       27423 :       params.set<std::vector<VariableName>>("arhouA") = {THM::RHOUA};
     335       18282 :       params.set<MaterialPropertyName>("direction") = THM::DIRECTION;
     336        9141 :       params.set<unsigned int>("component") = i;
     337       36564 :       params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     338        9141 :       _sim.addAuxKernel(class_name, genName(_comp_name, i, "vel_vec"), params);
     339        9141 :     }
     340        3047 :   }
     341             :   else
     342             :   {
     343        1020 :     const std::string class_name = "QuotientAux";
     344        1020 :     InputParameters params = _factory.getValidParams(class_name);
     345        2040 :     params.set<AuxVariableName>("variable") = THM::VELOCITY;
     346        2040 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     347        3060 :     params.set<std::vector<VariableName>>("numerator") = {THM::RHOUA};
     348        3060 :     params.set<std::vector<VariableName>>("denominator") = {THM::RHOA};
     349        4080 :     params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     350        2040 :     _sim.addAuxKernel(class_name, genName(_comp_name, "vel"), params);
     351        1020 :   }
     352       14228 : }
     353             : 
     354             : void
     355        4067 : FlowModel1PhaseBase::addDensityAux()
     356             : {
     357        4067 :   const std::string class_name = "QuotientAux";
     358        4067 :   InputParameters params = _factory.getValidParams(class_name);
     359        8134 :   params.set<AuxVariableName>("variable") = THM::DENSITY;
     360        8134 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     361       12201 :   params.set<std::vector<VariableName>>("numerator") = {THM::RHOA};
     362       12201 :   params.set<std::vector<VariableName>>("denominator") = {THM::AREA};
     363       16268 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     364        8134 :   _sim.addAuxKernel(class_name, genName(_comp_name, "rho_aux"), params);
     365       12201 : }
     366             : 
     367             : void
     368        4067 : FlowModel1PhaseBase::addSpecificVolumeAux()
     369             : {
     370        4067 :   const std::string class_name = "THMSpecificVolumeAux";
     371        4067 :   InputParameters params = _factory.getValidParams(class_name);
     372        8134 :   params.set<AuxVariableName>("variable") = THM::SPECIFIC_VOLUME;
     373        8134 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     374       12201 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     375       12201 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     376       16268 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     377        8134 :   _sim.addAuxKernel(class_name, genName(_comp_name, "v_aux"), params);
     378       12201 : }
     379             : 
     380             : void
     381        4067 : FlowModel1PhaseBase::addSpecificInternalEnergyAux()
     382             : {
     383        4067 :   const std::string class_name = "THMSpecificInternalEnergyAux";
     384        4067 :   InputParameters params = _factory.getValidParams(class_name);
     385        8134 :   params.set<AuxVariableName>("variable") = THM::SPECIFIC_INTERNAL_ENERGY;
     386        8134 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     387       12201 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     388       12201 :   params.set<std::vector<VariableName>>("rhouA") = {THM::RHOUA};
     389       12201 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     390       16268 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     391        8134 :   _sim.addAuxKernel(class_name, genName(_comp_name, "e_aux"), params);
     392       12201 : }
     393             : 
     394             : void
     395        4067 : FlowModel1PhaseBase::addSpecificTotalEnthalpyAux()
     396             : {
     397        4067 :   const std::string class_name = "SpecificTotalEnthalpyAux";
     398        4067 :   InputParameters params = _factory.getValidParams(class_name);
     399        8134 :   params.set<AuxVariableName>("variable") = THM::SPECIFIC_TOTAL_ENTHALPY;
     400        8134 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     401       12201 :   params.set<std::vector<VariableName>>("rhoA") = {THM::RHOA};
     402       12201 :   params.set<std::vector<VariableName>>("rhoEA") = {THM::RHOEA};
     403       12201 :   params.set<std::vector<VariableName>>("p") = {THM::PRESSURE};
     404       12201 :   params.set<std::vector<VariableName>>("A") = {THM::AREA};
     405       16268 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     406        8134 :   _sim.addAuxKernel(class_name, genName(_comp_name, "H_auxkernel"), params);
     407       12201 : }
     408             : 
     409             : void
     410        4067 : FlowModel1PhaseBase::addRDGMooseObjects()
     411             : {
     412        4067 :   addSlopeReconstructionMaterial();
     413        4067 :   addRDGAdvectionDGKernels();
     414        4067 : }
     415             : 
     416             : void
     417       12144 : FlowModel1PhaseBase::addVariableStepFunctorMaterial(const std::string & variable)
     418             : {
     419       12144 :   const std::string class_name = "FunctorChangeFunctorMaterial";
     420       12144 :   InputParameters params = _factory.getValidParams(class_name);
     421       24288 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     422       24288 :   params.set<MooseFunctorName>("functor") = THM::functorMaterialPropertyName<false>(variable);
     423       24288 :   params.set<MooseEnum>("change_over") = "nonlinear";
     424       24288 :   params.set<std::string>("prop_name") = variable + "_change";
     425       12144 :   params.set<bool>("take_absolute_value") = true;
     426       24288 :   _sim.addFunctorMaterial(class_name, genName(_comp_name, variable + "_step_fmat"), params);
     427       24288 : }
     428             : 
     429             : void
     430       12144 : FlowModel1PhaseBase::addNormalizedVariableStepPP(const std::string & variable, Real normalization)
     431             : {
     432       12144 :   const std::string class_name = "ElementExtremeFunctorValue";
     433       12144 :   InputParameters params = _factory.getValidParams(class_name);
     434       12144 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     435       24288 :   params.set<MooseEnum>("value_type") = "max";
     436       36432 :   params.set<MooseFunctorName>("functor") = variable + "_change";
     437       12144 :   params.set<Real>("scale") = 1.0 / normalization;
     438       24288 :   params.set<ExecFlagEnum>("execute_on") = EXEC_NONLINEAR_CONVERGENCE;
     439       36432 :   params.set<std::vector<OutputName>>("outputs") = {"none"};
     440       24288 :   _sim.addPostprocessor(class_name, genName(_comp_name, variable + "_rel_step"), params);
     441       24288 : }
     442             : 
     443             : void
     444       12144 : FlowModel1PhaseBase::addNormalized1PhaseResidualNorm(const VariableName & variable,
     445             :                                                      const std::string & equation)
     446             : {
     447       12144 :   const std::string class_name = "Normalized1PhaseResidualNorm";
     448       12144 :   InputParameters params = _factory.getValidParams(class_name);
     449       12144 :   params.set<VariableName>("variable") = variable;
     450       12144 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     451       24288 :   params.set<MooseEnum>("norm_type") = "l_inf";
     452       12144 :   params.set<Real>("p_ref") = _p_ref;
     453       12144 :   params.set<Real>("T_ref") = _T_ref;
     454       12144 :   params.set<Real>("vel_ref") = _vel_ref;
     455       36432 :   params.set<FunctionName>("A") = getParam<FunctionName>("A_function");
     456       12144 :   params.set<Point>("point") = _mid_point;
     457       12144 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     458       12144 :   params.set<Real>("min_elem_size") = _flow_channel.getMinimumElemSize();
     459       24288 :   params.set<ExecFlagEnum>("execute_on") = EXEC_NONLINEAR_CONVERGENCE;
     460       36432 :   params.set<std::vector<OutputName>>("outputs") = {"none"};
     461       24288 :   _sim.addPostprocessor(class_name, genName(_comp_name, equation + "_res"), params);
     462       24288 : }