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