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