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 "FlowModelSinglePhase.h"
      11             : #include "FlowChannelBase.h"
      12             : #include "THMNames.h"
      13             : 
      14             : const std::string FlowModelSinglePhase::DENSITY = THM::DENSITY;
      15             : const std::string FlowModelSinglePhase::FRICTION_FACTOR_DARCY = THM::FRICTION_FACTOR_DARCY;
      16             : const std::string FlowModelSinglePhase::DYNAMIC_VISCOSITY = THM::DYNAMIC_VISCOSITY;
      17             : const std::string FlowModelSinglePhase::HEAT_TRANSFER_COEFFICIENT_WALL =
      18             :     THM::HEAT_TRANSFER_COEFFICIENT_WALL;
      19             : const std::string FlowModelSinglePhase::HYDRAULIC_DIAMETER = THM::HYDRAULIC_DIAMETER;
      20             : const std::string FlowModelSinglePhase::PRESSURE = THM::PRESSURE;
      21             : const std::string FlowModelSinglePhase::RHOA = THM::RHOA;
      22             : const std::string FlowModelSinglePhase::RHOEA = THM::RHOEA;
      23             : const std::string FlowModelSinglePhase::RHOUA = THM::RHOUA;
      24             : const std::string FlowModelSinglePhase::SOUND_SPEED = THM::SOUND_SPEED;
      25             : const std::string FlowModelSinglePhase::SPECIFIC_HEAT_CONSTANT_PRESSURE =
      26             :     THM::SPECIFIC_HEAT_CONSTANT_PRESSURE;
      27             : const std::string FlowModelSinglePhase::SPECIFIC_HEAT_CONSTANT_VOLUME =
      28             :     THM::SPECIFIC_HEAT_CONSTANT_VOLUME;
      29             : const std::string FlowModelSinglePhase::SPECIFIC_INTERNAL_ENERGY = THM::SPECIFIC_INTERNAL_ENERGY;
      30             : const std::string FlowModelSinglePhase::SPECIFIC_TOTAL_ENTHALPY = THM::SPECIFIC_TOTAL_ENTHALPY;
      31             : const std::string FlowModelSinglePhase::SPECIFIC_VOLUME = THM::SPECIFIC_VOLUME;
      32             : const std::string FlowModelSinglePhase::TEMPERATURE = THM::TEMPERATURE;
      33             : const std::string FlowModelSinglePhase::THERMAL_CONDUCTIVITY = THM::THERMAL_CONDUCTIVITY;
      34             : const std::string FlowModelSinglePhase::VELOCITY = THM::VELOCITY;
      35             : const std::string FlowModelSinglePhase::VELOCITY_X = THM::VELOCITY_X;
      36             : const std::string FlowModelSinglePhase::VELOCITY_Y = THM::VELOCITY_Y;
      37             : const std::string FlowModelSinglePhase::VELOCITY_Z = THM::VELOCITY_Z;
      38             : const std::string FlowModelSinglePhase::REYNOLDS_NUMBER = THM::REYNOLDS_NUMBER;
      39             : 
      40             : InputParameters
      41        4266 : FlowModelSinglePhase::validParams()
      42             : {
      43        4266 :   InputParameters params = FlowModel1PhaseBase::validParams();
      44             : 
      45        8532 :   MooseEnum wave_speed_formulation("einfeldt davis", "einfeldt");
      46        8532 :   params.addParam<MooseEnum>(
      47             :       "wave_speed_formulation", wave_speed_formulation, "Method for computing wave speeds");
      48             : 
      49        8532 :   params.addRequiredParam<std::vector<Real>>(
      50             :       "scaling_factor_1phase",
      51             :       "Scaling factors for each single phase variable (rhoA, rhouA, rhoEA)");
      52             : 
      53        4266 :   return params;
      54        4266 : }
      55             : 
      56             : registerMooseObject("ThermalHydraulicsApp", FlowModelSinglePhase);
      57             : 
      58        2133 : FlowModelSinglePhase::FlowModelSinglePhase(const InputParameters & params)
      59             :   : FlowModel1PhaseBase(params),
      60        6399 :     _scaling_factors(getParam<std::vector<Real>>("scaling_factor_1phase"))
      61             : {
      62             :   // create passive transport solution variables, if any
      63        2133 :   const auto & passives_names = _flow_channel.getParam<std::vector<VariableName>>("passives_names");
      64        2133 :   _passives_times_area_names.resize(passives_names.size());
      65        2151 :   for (const auto i : index_range(passives_names))
      66          36 :     _passives_times_area_names[i] = passives_names[i] + "_times_area";
      67        2133 : }
      68             : 
      69             : Real
      70        2037 : FlowModelSinglePhase::getScalingFactorRhoA() const
      71             : {
      72        2037 :   return _scaling_factors[0];
      73             : }
      74             : 
      75             : Real
      76        2037 : FlowModelSinglePhase::getScalingFactorRhoUA() const
      77             : {
      78        2037 :   return _scaling_factors[1];
      79             : }
      80             : 
      81             : Real
      82        2037 : FlowModelSinglePhase::getScalingFactorRhoEA() const
      83             : {
      84        2037 :   return _scaling_factors[2];
      85             : }
      86             : 
      87             : void
      88        2037 : FlowModelSinglePhase::addVariables()
      89             : {
      90        2037 :   FlowModel1PhaseBase::addVariables();
      91             : 
      92             :   // Add passive transport variables
      93             :   const auto scaling_factor_passives =
      94        4074 :       _flow_channel.isParamSetByUser("scaling_factor_passives")
      95        2037 :           ? _flow_channel.getParam<std::vector<Real>>("scaling_factor_passives")
      96        2037 :           : std::vector<Real>(_passives_times_area_names.size(), 1.0);
      97             :   mooseAssert(scaling_factor_passives.size() == _passives_times_area_names.size(),
      98             :               "'scaling_factor_passives' size must match number of passives.");
      99        2055 :   for (const auto i : index_range(_passives_times_area_names))
     100          18 :     _sim.addSimVariable(true,
     101             :                         _passives_times_area_names[i],
     102          18 :                         _fe_type,
     103          18 :                         _flow_channel.getSubdomainNames(),
     104             :                         scaling_factor_passives[i]);
     105        2037 : }
     106             : 
     107             : std::vector<VariableName>
     108        8616 : FlowModelSinglePhase::solutionVariableNames() const
     109             : {
     110       34464 :   std::vector<VariableName> vars = {RHOA, RHOUA, RHOEA};
     111        8616 :   vars.insert(vars.end(), _passives_times_area_names.begin(), _passives_times_area_names.end());
     112        8616 :   return vars;
     113           0 : }
     114             : 
     115             : void
     116        2037 : FlowModelSinglePhase::addInitialConditions()
     117             : {
     118        2037 :   FlowModel1PhaseBase::addInitialConditions();
     119             : 
     120             :   // passive transport variables
     121             :   const auto & passives_ic_fn_names =
     122        4074 :       _flow_channel.getParam<std::vector<FunctionName>>("initial_passives");
     123        2055 :   for (const auto i : index_range(_passives_times_area_names))
     124          18 :     addPassiveTransportIC(_passives_times_area_names[i], passives_ic_fn_names[i]);
     125        2037 : }
     126             : 
     127             : void
     128        2037 : FlowModelSinglePhase::addKernels()
     129             : {
     130        2037 :   FlowModel1PhaseBase::addKernels();
     131             : 
     132             :   // time derivatives for passive transport variables
     133        2055 :   for (const auto & var : _passives_times_area_names)
     134          18 :     addTimeDerivativeKernelIfTransient(var);
     135        2037 : }
     136             : 
     137             : void
     138          18 : FlowModelSinglePhase::addPassiveTransportIC(const VariableName & var, const FunctionName & ic_fn)
     139             : {
     140          18 :   const std::string class_name = "VariableFunctionProductIC";
     141          18 :   InputParameters params = _factory.getValidParams(class_name);
     142          18 :   params.set<VariableName>("variable") = var;
     143          18 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     144          36 :   params.set<FunctionName>("fn") = ic_fn;
     145          54 :   params.set<std::vector<VariableName>>("var") = {THM::AREA};
     146          36 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, var + "_ic"), params);
     147          36 : }
     148             : 
     149             : void
     150        1991 : FlowModelSinglePhase::addRhoEAIC()
     151             : {
     152        1991 :   const std::string class_name = "RhoEAFromPressureTemperatureFunctionVelocityIC";
     153        1991 :   InputParameters params = _factory.getValidParams(class_name);
     154        3982 :   params.set<VariableName>("variable") = RHOEA;
     155        3982 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     156        5973 :   params.set<std::vector<VariableName>>("p") = {PRESSURE};
     157        5973 :   params.set<std::vector<VariableName>>("T") = {TEMPERATURE};
     158        3982 :   params.set<FunctionName>("vel") = getVariableFn("initial_vel");
     159        5973 :   params.set<std::vector<VariableName>>("A") = {FlowModel::AREA};
     160        1991 :   params.set<UserObjectName>("fp") = _fp_name;
     161        3982 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rhoEA_ic"), params);
     162        3982 : }
     163             : 
     164             : void
     165        1991 : FlowModelSinglePhase::addDensityIC()
     166             : {
     167        1991 :   const std::string class_name = "RhoFromPressureTemperatureIC";
     168        1991 :   InputParameters params = _factory.getValidParams(class_name);
     169        3982 :   params.set<VariableName>("variable") = DENSITY;
     170        3982 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     171        5973 :   params.set<std::vector<VariableName>>("p") = {PRESSURE};
     172        5973 :   params.set<std::vector<VariableName>>("T") = {TEMPERATURE};
     173        1991 :   params.set<UserObjectName>("fp") = _fp_name;
     174        3982 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rho_ic"), params);
     175        3982 : }
     176             : 
     177             : void
     178        2037 : FlowModelSinglePhase::addPressureAux()
     179             : {
     180        2037 :   const std::string class_name = "PressureAux";
     181        2037 :   InputParameters params = _factory.getValidParams(class_name);
     182        4074 :   params.set<AuxVariableName>("variable") = PRESSURE;
     183        4074 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     184        6111 :   params.set<std::vector<VariableName>>("e") = {SPECIFIC_INTERNAL_ENERGY};
     185        6111 :   params.set<std::vector<VariableName>>("v") = {SPECIFIC_VOLUME};
     186        2037 :   params.set<UserObjectName>("fp") = _fp_name;
     187        4074 :   _sim.addAuxKernel(class_name, genName(_comp_name, "pressure_uv_auxkernel"), params);
     188        4074 : }
     189             : 
     190             : void
     191        2037 : FlowModelSinglePhase::addTemperatureAux()
     192             : {
     193        2037 :   const std::string class_name = "TemperatureAux";
     194        2037 :   InputParameters params = _factory.getValidParams(class_name);
     195        4074 :   params.set<AuxVariableName>("variable") = TEMPERATURE;
     196        4074 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     197        6111 :   params.set<std::vector<VariableName>>("e") = {SPECIFIC_INTERNAL_ENERGY};
     198        6111 :   params.set<std::vector<VariableName>>("v") = {SPECIFIC_VOLUME};
     199        2037 :   params.set<UserObjectName>("fp") = _fp_name;
     200        4074 :   _sim.addAuxKernel(class_name, genName(_comp_name, "T_auxkernel"), params);
     201        4074 : }
     202             : 
     203             : void
     204        2037 : FlowModelSinglePhase::addFluidPropertiesMaterials()
     205             : {
     206             :   {
     207        2037 :     const std::string class_name = "ADFluidProperties3EqnMaterial";
     208        2037 :     InputParameters params = _factory.getValidParams(class_name);
     209        2037 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     210        4074 :     params.set<UserObjectName>("fp") = _fp_name;
     211        6111 :     params.set<std::vector<VariableName>>("rhoA") = {RHOA};
     212        6111 :     params.set<std::vector<VariableName>>("rhouA") = {RHOUA};
     213        6111 :     params.set<std::vector<VariableName>>("rhoEA") = {RHOEA};
     214        6111 :     params.set<std::vector<VariableName>>("A") = {FlowModel::AREA};
     215        4074 :     _sim.addMaterial(class_name, genName(_comp_name, "fp_mat"), params);
     216        2037 :   }
     217             :   {
     218        2037 :     const std::string class_name = "ADDynamicViscosityMaterial";
     219        2037 :     InputParameters params = _factory.getValidParams(class_name);
     220        2037 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     221        4074 :     params.set<UserObjectName>("fp_1phase") = _fp_name;
     222        4074 :     params.set<MaterialPropertyName>("mu") = {DYNAMIC_VISCOSITY};
     223        4074 :     params.set<MaterialPropertyName>("v") = {SPECIFIC_VOLUME};
     224        4074 :     params.set<MaterialPropertyName>("e") = {SPECIFIC_INTERNAL_ENERGY};
     225        4074 :     _sim.addMaterial(class_name, genName(_comp_name, "mu_mat"), params);
     226        2037 :   }
     227        2037 : }
     228             : 
     229             : void
     230        2037 : FlowModelSinglePhase::addNumericalFluxUserObject()
     231             : {
     232        2037 :   const std::string class_name = "ADNumericalFlux3EqnHLLC";
     233        2037 :   InputParameters params = _factory.getValidParams(class_name);
     234        2037 :   params.applySpecificParameters(parameters(), {"wave_speed_formulation"});
     235        2037 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     236        4074 :   params.set<MooseEnum>("emit_on_nan") = "none";
     237       10185 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
     238        2037 :   _sim.addUserObject(class_name, _numerical_flux_name, params);
     239        6111 : }
     240             : 
     241             : void
     242        2037 : FlowModelSinglePhase::addSlopeReconstructionMaterial()
     243             : {
     244        2037 :   const std::string class_name = "ADRDG3EqnMaterial";
     245        2037 :   InputParameters params = _factory.getValidParams(class_name);
     246        2037 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     247        4074 :   params.set<MooseEnum>("scheme") = _rdg_slope_reconstruction;
     248        6111 :   params.set<std::vector<VariableName>>("A_elem") = {AREA};
     249        6111 :   params.set<std::vector<VariableName>>("A_linear") = {AREA_LINEAR};
     250        6111 :   params.set<std::vector<VariableName>>("rhoA") = {RHOA};
     251        6111 :   params.set<std::vector<VariableName>>("rhouA") = {RHOUA};
     252        6111 :   params.set<std::vector<VariableName>>("rhoEA") = {RHOEA};
     253        4074 :   params.set<std::vector<VariableName>>("passives_times_area") = _passives_times_area_names;
     254        4074 :   params.set<MaterialPropertyName>("direction") = DIRECTION;
     255        2037 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     256        2037 :   params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     257        4074 :   _sim.addMaterial(class_name, genName(_comp_name, "rdg_3egn_mat"), params);
     258        4074 : }
     259             : 
     260             : void
     261        2037 : FlowModelSinglePhase::addRDGAdvectionDGKernels()
     262             : {
     263        8166 :   for (const auto & var : solutionVariableNames())
     264             :   {
     265        6129 :     const std::string class_name = "ADNumericalFlux3EqnDGKernel";
     266        6129 :     InputParameters params = _factory.getValidParams(class_name);
     267       12258 :     params.set<NonlinearVariableName>("variable") = var;
     268       12258 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     269       18387 :     params.set<std::vector<VariableName>>("A_linear") = {AREA_LINEAR};
     270       18387 :     params.set<std::vector<VariableName>>("rhoA") = {RHOA};
     271       18387 :     params.set<std::vector<VariableName>>("rhouA") = {RHOUA};
     272       18387 :     params.set<std::vector<VariableName>>("rhoEA") = {RHOEA};
     273        6129 :     params.set<std::vector<VariableName>>("passives_times_area") = _passives_times_area_names;
     274        6129 :     params.set<UserObjectName>("numerical_flux") = _numerical_flux_name;
     275        6129 :     params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     276       12258 :     _sim.addDGKernel(class_name, genName(_comp_name, "flux_kernel_" + var), params);
     277        8166 :   }
     278        2037 : }