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        8324 : FlowModelSinglePhase::validParams()
      42             : {
      43        8324 :   InputParameters params = FlowModel1PhaseBase::validParams();
      44             : 
      45       16648 :   MooseEnum wave_speed_formulation("einfeldt davis", "einfeldt");
      46       16648 :   params.addParam<MooseEnum>(
      47             :       "wave_speed_formulation", wave_speed_formulation, "Method for computing wave speeds");
      48             : 
      49       16648 :   params.addRequiredParam<std::vector<Real>>(
      50             :       "scaling_factor_1phase",
      51             :       "Scaling factors for each single phase variable (rhoA, rhouA, rhoEA)");
      52             : 
      53        8324 :   return params;
      54        8324 : }
      55             : 
      56             : registerMooseObject("ThermalHydraulicsApp", FlowModelSinglePhase);
      57             : 
      58        4162 : FlowModelSinglePhase::FlowModelSinglePhase(const InputParameters & params)
      59             :   : FlowModel1PhaseBase(params),
      60        8324 :     _scaling_factors(getParam<std::vector<Real>>("scaling_factor_1phase"))
      61             : {
      62        4162 : }
      63             : 
      64             : Real
      65        4048 : FlowModelSinglePhase::getScalingFactorRhoA() const
      66             : {
      67        4048 :   return _scaling_factors[0];
      68             : }
      69             : 
      70             : Real
      71        4048 : FlowModelSinglePhase::getScalingFactorRhoUA() const
      72             : {
      73        4048 :   return _scaling_factors[1];
      74             : }
      75             : 
      76             : Real
      77        4048 : FlowModelSinglePhase::getScalingFactorRhoEA() const
      78             : {
      79        4048 :   return _scaling_factors[2];
      80             : }
      81             : 
      82             : std::vector<VariableName>
      83        8096 : FlowModelSinglePhase::solutionVariableNames() const
      84             : {
      85       32384 :   return {RHOA, RHOUA, RHOEA};
      86           0 : }
      87             : 
      88             : void
      89        3986 : FlowModelSinglePhase::addRhoEAIC()
      90             : {
      91        3986 :   const std::string class_name = "RhoEAFromPressureTemperatureFunctionVelocityIC";
      92        3986 :   InputParameters params = _factory.getValidParams(class_name);
      93        7972 :   params.set<VariableName>("variable") = RHOEA;
      94        7972 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
      95       11958 :   params.set<std::vector<VariableName>>("p") = {PRESSURE};
      96       11958 :   params.set<std::vector<VariableName>>("T") = {TEMPERATURE};
      97        7972 :   params.set<FunctionName>("vel") = getVariableFn("initial_vel");
      98       11958 :   params.set<std::vector<VariableName>>("A") = {FlowModel::AREA};
      99        3986 :   params.set<UserObjectName>("fp") = _fp_name;
     100        7972 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rhoEA_ic"), params);
     101        7972 : }
     102             : 
     103             : void
     104        3986 : FlowModelSinglePhase::addDensityIC()
     105             : {
     106        3986 :   const std::string class_name = "RhoFromPressureTemperatureIC";
     107        3986 :   InputParameters params = _factory.getValidParams(class_name);
     108        7972 :   params.set<VariableName>("variable") = DENSITY;
     109        7972 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     110       11958 :   params.set<std::vector<VariableName>>("p") = {PRESSURE};
     111       11958 :   params.set<std::vector<VariableName>>("T") = {TEMPERATURE};
     112        3986 :   params.set<UserObjectName>("fp") = _fp_name;
     113        7972 :   _sim.addSimInitialCondition(class_name, genName(_comp_name, "rho_ic"), params);
     114        7972 : }
     115             : 
     116             : void
     117        4048 : FlowModelSinglePhase::addPressureAux()
     118             : {
     119        4048 :   const std::string class_name = "PressureAux";
     120        4048 :   InputParameters params = _factory.getValidParams(class_name);
     121        8096 :   params.set<AuxVariableName>("variable") = PRESSURE;
     122        8096 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     123       12144 :   params.set<std::vector<VariableName>>("e") = {SPECIFIC_INTERNAL_ENERGY};
     124       12144 :   params.set<std::vector<VariableName>>("v") = {SPECIFIC_VOLUME};
     125        4048 :   params.set<UserObjectName>("fp") = _fp_name;
     126        8096 :   _sim.addAuxKernel(class_name, genName(_comp_name, "pressure_uv_auxkernel"), params);
     127        8096 : }
     128             : 
     129             : void
     130        4048 : FlowModelSinglePhase::addTemperatureAux()
     131             : {
     132        4048 :   const std::string class_name = "TemperatureAux";
     133        4048 :   InputParameters params = _factory.getValidParams(class_name);
     134        8096 :   params.set<AuxVariableName>("variable") = TEMPERATURE;
     135        8096 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     136       12144 :   params.set<std::vector<VariableName>>("e") = {SPECIFIC_INTERNAL_ENERGY};
     137       12144 :   params.set<std::vector<VariableName>>("v") = {SPECIFIC_VOLUME};
     138        4048 :   params.set<UserObjectName>("fp") = _fp_name;
     139        8096 :   _sim.addAuxKernel(class_name, genName(_comp_name, "T_auxkernel"), params);
     140        8096 : }
     141             : 
     142             : void
     143        4048 : FlowModelSinglePhase::addFunctorMaterials()
     144             : {
     145             :   {
     146        4048 :     const std::string class_name = "FlowModel1PhaseFunctorMaterial";
     147        8096 :     const std::string obj_name = genName(_comp_name, "fm1phase_fmat");
     148        4048 :     InputParameters params = _factory.getValidParams(class_name);
     149        4048 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     150        4048 :     params.set<UserObjectName>("fluid_properties") = _fp_name;
     151        4048 :     _sim.addFunctorMaterial(class_name, obj_name, params);
     152        4048 :   }
     153             : 
     154             :   // nonlinear step functor materials for p, T, vel (for convergence checking)
     155       16192 :   const std::vector<std::string> vars{THM::PRESSURE, THM::TEMPERATURE, THM::VELOCITY};
     156       16192 :   for (const auto & var : vars)
     157       12144 :     addVariableStepFunctorMaterial(var);
     158        8096 : }
     159             : 
     160             : void
     161        4048 : FlowModelSinglePhase::addFluidPropertiesMaterials()
     162             : {
     163             :   {
     164        4048 :     const std::string class_name = "ADFluidProperties3EqnMaterial";
     165        4048 :     InputParameters params = _factory.getValidParams(class_name);
     166        4048 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     167        8096 :     params.set<UserObjectName>("fp") = _fp_name;
     168       12144 :     params.set<std::vector<VariableName>>("rhoA") = {RHOA};
     169       12144 :     params.set<std::vector<VariableName>>("rhouA") = {RHOUA};
     170       12144 :     params.set<std::vector<VariableName>>("rhoEA") = {RHOEA};
     171       12144 :     params.set<std::vector<VariableName>>("A") = {FlowModel::AREA};
     172        8096 :     _sim.addMaterial(class_name, genName(_comp_name, "fp_mat"), params);
     173        4048 :   }
     174             :   {
     175        4048 :     const std::string class_name = "ADDynamicViscosityMaterial";
     176        4048 :     InputParameters params = _factory.getValidParams(class_name);
     177        4048 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     178        8096 :     params.set<UserObjectName>("fp_1phase") = _fp_name;
     179        8096 :     params.set<MaterialPropertyName>("mu") = {DYNAMIC_VISCOSITY};
     180        8096 :     params.set<MaterialPropertyName>("v") = {SPECIFIC_VOLUME};
     181        8096 :     params.set<MaterialPropertyName>("e") = {SPECIFIC_INTERNAL_ENERGY};
     182        8096 :     _sim.addMaterial(class_name, genName(_comp_name, "mu_mat"), params);
     183        4048 :   }
     184        4048 : }
     185             : 
     186             : void
     187        4048 : FlowModelSinglePhase::addNumericalFluxUserObject()
     188             : {
     189        4048 :   const std::string class_name = "ADNumericalFlux3EqnHLLC";
     190        4048 :   InputParameters params = _factory.getValidParams(class_name);
     191        4048 :   params.applySpecificParameters(parameters(), {"wave_speed_formulation"});
     192        4048 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     193        8096 :   params.set<MooseEnum>("emit_on_nan") = "none";
     194       20240 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
     195        4048 :   _sim.addUserObject(class_name, _numerical_flux_name, params);
     196       12144 : }
     197             : 
     198             : void
     199        4048 : FlowModelSinglePhase::addSlopeReconstructionMaterial()
     200             : {
     201        4048 :   const std::string class_name = "ADRDG3EqnMaterial";
     202        4048 :   InputParameters params = _factory.getValidParams(class_name);
     203        4048 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     204        8096 :   params.set<MooseEnum>("scheme") = _rdg_slope_reconstruction;
     205       12144 :   params.set<std::vector<VariableName>>("A_elem") = {AREA};
     206       12144 :   params.set<std::vector<VariableName>>("A_linear") = {AREA_LINEAR};
     207       12144 :   params.set<std::vector<VariableName>>("rhoA") = {RHOA};
     208       12144 :   params.set<std::vector<VariableName>>("rhouA") = {RHOUA};
     209       12144 :   params.set<std::vector<VariableName>>("rhoEA") = {RHOEA};
     210        8096 :   params.set<MaterialPropertyName>("direction") = DIRECTION;
     211        4048 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     212        4048 :   params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     213        8096 :   _sim.addMaterial(class_name, genName(_comp_name, "rdg_3egn_mat"), params);
     214        8096 : }
     215             : 
     216             : void
     217        4048 : FlowModelSinglePhase::addRDGAdvectionDGKernels()
     218             : {
     219             :   // mass
     220        4048 :   const std::string class_name = "ADNumericalFlux3EqnDGKernel";
     221        4048 :   InputParameters params = _factory.getValidParams(class_name);
     222        8096 :   params.set<NonlinearVariableName>("variable") = RHOA;
     223        8096 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     224       12144 :   params.set<std::vector<VariableName>>("A_linear") = {AREA_LINEAR};
     225       12144 :   params.set<std::vector<VariableName>>("rhoA") = {RHOA};
     226       12144 :   params.set<std::vector<VariableName>>("rhouA") = {RHOUA};
     227       12144 :   params.set<std::vector<VariableName>>("rhoEA") = {RHOEA};
     228        4048 :   params.set<UserObjectName>("numerical_flux") = _numerical_flux_name;
     229        4048 :   params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     230        8096 :   _sim.addDGKernel(class_name, genName(_comp_name, "mass_advection"), params);
     231             : 
     232             :   // momentum
     233        8096 :   params.set<NonlinearVariableName>("variable") = RHOUA;
     234        8096 :   _sim.addDGKernel(class_name, genName(_comp_name, "momentum_advection"), params);
     235             : 
     236             :   // energy
     237        8096 :   params.set<NonlinearVariableName>("variable") = RHOEA;
     238        8096 :   _sim.addDGKernel(class_name, genName(_comp_name, "energy_advection"), params);
     239        8096 : }
     240             : 
     241             : void
     242        4048 : FlowModelSinglePhase::addPostprocessors()
     243             : {
     244             :   const std::vector<std::pair<std::string, Real>> var_norm_pairs{
     245       16192 :       {THM::PRESSURE, _p_ref}, {THM::TEMPERATURE, _T_ref}, {THM::VELOCITY, _vel_ref}};
     246       16192 :   for (const auto & var_norm_pair : var_norm_pairs)
     247       12144 :     addNormalizedVariableStepPP(var_norm_pair.first, var_norm_pair.second);
     248             : 
     249             :   const std::vector<std::pair<std::string, std::string>> var_eq_pairs{
     250       16192 :       {THM::RHOA, "mass"}, {THM::RHOUA, "momentum"}, {THM::RHOEA, "energy"}};
     251       16192 :   for (const auto & var_eq_pair : var_eq_pairs)
     252       24288 :     addNormalized1PhaseResidualNorm(var_eq_pair.first, var_eq_pair.second);
     253        8096 : }