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        8320 : FlowModelSinglePhase::validParams()
      42             : {
      43        8320 :   InputParameters params = FlowModel1PhaseBase::validParams();
      44             : 
      45       16640 :   MooseEnum wave_speed_formulation("einfeldt davis", "einfeldt");
      46       16640 :   params.addParam<MooseEnum>(
      47             :       "wave_speed_formulation", wave_speed_formulation, "Method for computing wave speeds");
      48             : 
      49       16640 :   params.addRequiredParam<std::vector<Real>>(
      50             :       "scaling_factor_1phase",
      51             :       "Scaling factors for each single phase variable (rhoA, rhouA, rhoEA)");
      52             : 
      53        8320 :   return params;
      54        8320 : }
      55             : 
      56             : registerMooseObject("ThermalHydraulicsApp", FlowModelSinglePhase);
      57             : 
      58        4160 : FlowModelSinglePhase::FlowModelSinglePhase(const InputParameters & params)
      59             :   : FlowModel1PhaseBase(params),
      60        8320 :     _scaling_factors(getParam<std::vector<Real>>("scaling_factor_1phase"))
      61             : {
      62        4160 : }
      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::addFluidPropertiesMaterials()
     144             : {
     145             :   {
     146        4048 :     const std::string class_name = "ADFluidProperties3EqnMaterial";
     147        4048 :     InputParameters params = _factory.getValidParams(class_name);
     148        4048 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     149        8096 :     params.set<UserObjectName>("fp") = _fp_name;
     150       12144 :     params.set<std::vector<VariableName>>("rhoA") = {RHOA};
     151       12144 :     params.set<std::vector<VariableName>>("rhouA") = {RHOUA};
     152       12144 :     params.set<std::vector<VariableName>>("rhoEA") = {RHOEA};
     153       12144 :     params.set<std::vector<VariableName>>("A") = {FlowModel::AREA};
     154        8096 :     _sim.addMaterial(class_name, genName(_comp_name, "fp_mat"), params);
     155        4048 :   }
     156             :   {
     157        4048 :     const std::string class_name = "ADDynamicViscosityMaterial";
     158        4048 :     InputParameters params = _factory.getValidParams(class_name);
     159        4048 :     params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     160        8096 :     params.set<UserObjectName>("fp_1phase") = _fp_name;
     161        8096 :     params.set<MaterialPropertyName>("mu") = {DYNAMIC_VISCOSITY};
     162        8096 :     params.set<MaterialPropertyName>("v") = {SPECIFIC_VOLUME};
     163        8096 :     params.set<MaterialPropertyName>("e") = {SPECIFIC_INTERNAL_ENERGY};
     164        8096 :     _sim.addMaterial(class_name, genName(_comp_name, "mu_mat"), params);
     165        4048 :   }
     166        4048 : }
     167             : 
     168             : void
     169        4048 : FlowModelSinglePhase::addNumericalFluxUserObject()
     170             : {
     171        4048 :   const std::string class_name = "ADNumericalFlux3EqnHLLC";
     172        4048 :   InputParameters params = _factory.getValidParams(class_name);
     173        4048 :   params.applySpecificParameters(parameters(), {"wave_speed_formulation"});
     174        4048 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     175        8096 :   params.set<MooseEnum>("emit_on_nan") = "none";
     176       20240 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
     177        4048 :   _sim.addUserObject(class_name, _numerical_flux_name, params);
     178       12144 : }
     179             : 
     180             : void
     181        4048 : FlowModelSinglePhase::addSlopeReconstructionMaterial()
     182             : {
     183        4048 :   const std::string class_name = "ADRDG3EqnMaterial";
     184        4048 :   InputParameters params = _factory.getValidParams(class_name);
     185        4048 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     186        8096 :   params.set<MooseEnum>("scheme") = _rdg_slope_reconstruction;
     187       12144 :   params.set<std::vector<VariableName>>("A_elem") = {AREA};
     188       12144 :   params.set<std::vector<VariableName>>("A_linear") = {AREA_LINEAR};
     189       12144 :   params.set<std::vector<VariableName>>("rhoA") = {RHOA};
     190       12144 :   params.set<std::vector<VariableName>>("rhouA") = {RHOUA};
     191       12144 :   params.set<std::vector<VariableName>>("rhoEA") = {RHOEA};
     192        8096 :   params.set<MaterialPropertyName>("direction") = DIRECTION;
     193        4048 :   params.set<UserObjectName>("fluid_properties") = _fp_name;
     194        4048 :   params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     195        8096 :   _sim.addMaterial(class_name, genName(_comp_name, "rdg_3egn_mat"), params);
     196        8096 : }
     197             : 
     198             : void
     199        4048 : FlowModelSinglePhase::addRDGAdvectionDGKernels()
     200             : {
     201             :   // mass
     202        4048 :   const std::string class_name = "ADNumericalFlux3EqnDGKernel";
     203        4048 :   InputParameters params = _factory.getValidParams(class_name);
     204        8096 :   params.set<NonlinearVariableName>("variable") = RHOA;
     205        8096 :   params.set<std::vector<SubdomainName>>("block") = _flow_channel.getSubdomainNames();
     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        4048 :   params.set<UserObjectName>("numerical_flux") = _numerical_flux_name;
     211        4048 :   params.set<bool>("implicit") = _sim.getImplicitTimeIntegrationFlag();
     212        8096 :   _sim.addDGKernel(class_name, genName(_comp_name, "mass_advection"), params);
     213             : 
     214             :   // momentum
     215        8096 :   params.set<NonlinearVariableName>("variable") = RHOUA;
     216        8096 :   _sim.addDGKernel(class_name, genName(_comp_name, "momentum_advection"), params);
     217             : 
     218             :   // energy
     219        8096 :   params.set<NonlinearVariableName>("variable") = RHOEA;
     220        8096 :   _sim.addDGKernel(class_name, genName(_comp_name, "energy_advection"), params);
     221        8096 : }