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 "FlowModelSetup1Phase.h"
      11             : #include "MooseObjectAction.h"
      12             : 
      13             : InputParameters
      14          20 : FlowModelSetup1Phase::validParams()
      15             : {
      16          20 :   InputParameters params = FlowModelSetup::validParams();
      17             : 
      18          40 :   params.addRequiredParam<FunctionName>("p", "Initial pressure function");
      19          40 :   params.addRequiredParam<FunctionName>("T", "Initial temperature function");
      20          40 :   params.addRequiredParam<FunctionName>("vel", "Initial velocity function");
      21          40 :   params.addRequiredParam<FunctionName>("A", "Area function");
      22          40 :   params.addParam<FunctionName>("D_h", 0, "Hydraulic diameter function");
      23             : 
      24          40 :   params.addParam<Real>("scaling_rhoA", 1.0, "Scaling factor for rho*A");
      25          40 :   params.addParam<Real>("scaling_rhouA", 1.0, "Scaling factor for rho*u*A");
      26          40 :   params.addParam<Real>("scaling_rhoEA", 1.0, "Scaling factor for rho*E*A");
      27             : 
      28          40 :   params.addRequiredParam<UserObjectName>("fp_1phase", "Single-phase fluid properties object name");
      29             : 
      30          20 :   return params;
      31           0 : }
      32             : 
      33          20 : FlowModelSetup1Phase::FlowModelSetup1Phase(const InputParameters & params)
      34             :   : FlowModelSetup(params),
      35             : 
      36          40 :     _p_fn(getParam<FunctionName>("p")),
      37          20 :     _T_fn(getParam<FunctionName>("T")),
      38          20 :     _vel_fn(getParam<FunctionName>("vel")),
      39          20 :     _A_fn(getParam<FunctionName>("A")),
      40          20 :     _D_h_fn(getParam<FunctionName>("D_h")),
      41             : 
      42          40 :     _fp_1phase_name(getParam<UserObjectName>("fp_1phase")),
      43             : 
      44             :     _unity_name("unity"),
      45             :     _A_name("A"),
      46             :     _D_h_name("D_h"),
      47             :     _rhoA_name("rhoA"),
      48             :     _rhouA_name("rhouA"),
      49             :     _rhoEA_name("rhoEA"),
      50             :     _rho_name("rho"),
      51             :     _vel_name("vel"),
      52             :     _p_name("p"),
      53             :     _T_name("T"),
      54             :     _v_name("v"),
      55             :     _e_name("e"),
      56             :     _H_name("H"),
      57             :     _mu_name("mu"),
      58          60 :     _ad(getParam<bool>("ad"))
      59             : {
      60          20 : }
      61             : 
      62             : void
      63          20 : FlowModelSetup1Phase::addInitialConditions()
      64             : {
      65          20 :   const std::string class_name = "AddInitialConditionAction";
      66             : 
      67          20 :   addFunctionIC(_A_name, _A_fn);
      68          20 :   addFunctionIC(_p_name, _p_fn);
      69          20 :   addFunctionIC(_T_name, _T_fn);
      70          20 :   addFunctionIC(_vel_name, _vel_fn);
      71             : 
      72             :   // rho
      73             :   {
      74          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
      75          20 :     params.set<std::string>("type") = "RhoFromPressureTemperatureIC";
      76             : 
      77             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
      78          40 :         _this_action_factory.create(class_name, _rho_name + "_ic", params));
      79             : 
      80          20 :     action->getObjectParams().set<VariableName>("variable") = _rho_name;
      81          40 :     action->getObjectParams().set<UserObjectName>("fp") = _fp_1phase_name;
      82          60 :     action->getObjectParams().set<std::vector<VariableName>>("p") = {_p_name};
      83          60 :     action->getObjectParams().set<std::vector<VariableName>>("T") = {_T_name};
      84             : 
      85          60 :     _this_action_warehouse.addActionBlock(action);
      86          20 :   }
      87             : 
      88             :   // rho*A
      89             :   {
      90          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
      91          20 :     params.set<std::string>("type") = "VariableProductIC";
      92             : 
      93             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
      94          40 :         _this_action_factory.create(class_name, _rhoA_name + "_ic", params));
      95             : 
      96          40 :     action->getObjectParams().set<VariableName>("variable") = _rhoA_name;
      97          80 :     action->getObjectParams().set<std::vector<VariableName>>("values") = {_rho_name, _A_name};
      98             : 
      99          60 :     _this_action_warehouse.addActionBlock(action);
     100          20 :   }
     101             :   // rho*u*A
     102             :   {
     103          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     104          20 :     params.set<std::string>("type") = "VariableProductIC";
     105             : 
     106             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     107          40 :         _this_action_factory.create(class_name, _rhouA_name + "_ic", params));
     108             : 
     109          40 :     action->getObjectParams().set<VariableName>("variable") = _rhouA_name;
     110          40 :     action->getObjectParams().set<std::vector<VariableName>>("values") = {
     111         120 :         _rho_name, _vel_name, _A_name};
     112             : 
     113          60 :     _this_action_warehouse.addActionBlock(action);
     114          20 :   }
     115             :   // rho*E*A
     116             :   {
     117          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     118          20 :     params.set<std::string>("type") = "RhoEAFromPressureTemperatureVelocityIC";
     119             : 
     120             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     121          40 :         _this_action_factory.create(class_name, _rhoEA_name + "_ic", params));
     122             : 
     123          20 :     action->getObjectParams().set<VariableName>("variable") = _rhoEA_name;
     124          40 :     action->getObjectParams().set<UserObjectName>("fp") = _fp_1phase_name;
     125          60 :     action->getObjectParams().set<std::vector<VariableName>>("p") = {_p_name};
     126          60 :     action->getObjectParams().set<std::vector<VariableName>>("T") = {_T_name};
     127          60 :     action->getObjectParams().set<std::vector<VariableName>>("vel") = {_vel_name};
     128          60 :     action->getObjectParams().set<std::vector<VariableName>>("A") = {_A_name};
     129             : 
     130          60 :     _this_action_warehouse.addActionBlock(action);
     131          20 :   }
     132             : 
     133             :   // specific volume
     134             :   {
     135          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     136          20 :     params.set<std::string>("type") = "SpecificVolumeIC";
     137             : 
     138             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     139          40 :         _this_action_factory.create(class_name, _v_name + "_ic", params));
     140             : 
     141          40 :     action->getObjectParams().set<VariableName>("variable") = _v_name;
     142          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoA") = {_rhoA_name};
     143          60 :     action->getObjectParams().set<std::vector<VariableName>>("A") = {_A_name};
     144             : 
     145          60 :     _this_action_warehouse.addActionBlock(action);
     146          20 :   }
     147             :   // specific internal energy
     148             :   {
     149          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     150          20 :     params.set<std::string>("type") = "SpecificInternalEnergyIC";
     151             : 
     152             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     153          40 :         _this_action_factory.create(class_name, _e_name + "_ic", params));
     154             : 
     155          40 :     action->getObjectParams().set<VariableName>("variable") = _e_name;
     156          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoA") = {_rhoA_name};
     157          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhouA") = {_rhouA_name};
     158          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoEA") = {_rhoEA_name};
     159             : 
     160          60 :     _this_action_warehouse.addActionBlock(action);
     161          20 :   }
     162             :   // total specific enthalpy
     163             :   {
     164          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     165          20 :     params.set<std::string>("type") = "SpecificTotalEnthalpyIC";
     166             : 
     167             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     168          40 :         _this_action_factory.create(class_name, _H_name + "_ic", params));
     169             : 
     170          40 :     action->getObjectParams().set<VariableName>("variable") = _H_name;
     171          60 :     action->getObjectParams().set<std::vector<VariableName>>("p") = {_p_name};
     172          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoA") = {_rhoA_name};
     173          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoEA") = {_rhoEA_name};
     174          60 :     action->getObjectParams().set<std::vector<VariableName>>("A") = {_A_name};
     175             : 
     176          60 :     _this_action_warehouse.addActionBlock(action);
     177          20 :   }
     178          20 : }
     179             : 
     180             : void
     181          20 : FlowModelSetup1Phase::addSolutionVariables()
     182             : {
     183          80 :   std::vector<VariableName> var_names{_rhoA_name, _rhouA_name, _rhoEA_name};
     184          80 :   for (const VariableName & var_name : var_names)
     185             :   {
     186         120 :     const Real scaling_factor = getParam<Real>("scaling_" + var_name);
     187          60 :     addSolutionVariable(var_name, scaling_factor);
     188             :   }
     189          20 : }
     190             : 
     191             : void
     192          20 : FlowModelSetup1Phase::addNonConstantAuxVariables()
     193             : {
     194             :   // area
     195          20 :   addAuxVariable(_A_name);
     196             :   {
     197          20 :     const std::string class_name = "AddKernelAction";
     198          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     199          20 :     params.set<std::string>("type") = "FunctionAux";
     200          20 :     params.set<std::string>("task") = "add_aux_kernel";
     201             : 
     202             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     203          40 :         _this_action_factory.create(class_name, _A_name + "_aux", params));
     204             : 
     205          40 :     action->getObjectParams().set<AuxVariableName>("variable") = _A_name;
     206          20 :     action->getObjectParams().set<FunctionName>("function") = _A_fn;
     207             : 
     208          60 :     _this_action_warehouse.addActionBlock(action);
     209          20 :   }
     210             : 
     211             :   // rho
     212          20 :   addAuxVariable(_rho_name);
     213             :   {
     214          20 :     const std::string class_name = "AddKernelAction";
     215          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     216          20 :     params.set<std::string>("type") = "QuotientAux";
     217          20 :     params.set<std::string>("task") = "add_aux_kernel";
     218             : 
     219             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     220          40 :         _this_action_factory.create(class_name, _rho_name + "_aux", params));
     221             : 
     222          40 :     action->getObjectParams().set<AuxVariableName>("variable") = _rho_name;
     223          60 :     action->getObjectParams().set<std::vector<VariableName>>("numerator") = {_rhoA_name};
     224          60 :     action->getObjectParams().set<std::vector<VariableName>>("denominator") = {_A_name};
     225             : 
     226          60 :     _this_action_warehouse.addActionBlock(action);
     227          20 :   }
     228             : 
     229             :   // velocity
     230          20 :   addAuxVariable(_vel_name);
     231             :   {
     232          20 :     const std::string class_name = "AddKernelAction";
     233          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     234          20 :     params.set<std::string>("type") = "QuotientAux";
     235          20 :     params.set<std::string>("task") = "add_aux_kernel";
     236             : 
     237             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     238          40 :         _this_action_factory.create(class_name, _vel_name + "_aux", params));
     239             : 
     240          40 :     action->getObjectParams().set<AuxVariableName>("variable") = _vel_name;
     241          60 :     action->getObjectParams().set<std::vector<VariableName>>("numerator") = {_rhouA_name};
     242          60 :     action->getObjectParams().set<std::vector<VariableName>>("denominator") = {_rhoA_name};
     243             : 
     244          60 :     _this_action_warehouse.addActionBlock(action);
     245          20 :   }
     246             : 
     247             :   // pressure
     248          20 :   addAuxVariable(_p_name);
     249             :   {
     250          20 :     const std::string class_name = "AddKernelAction";
     251          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     252          20 :     params.set<std::string>("type") = "PressureAux";
     253          20 :     params.set<std::string>("task") = "add_aux_kernel";
     254             : 
     255             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     256          40 :         _this_action_factory.create(class_name, _p_name + "_aux", params));
     257             : 
     258          40 :     action->getObjectParams().set<AuxVariableName>("variable") = _p_name;
     259          60 :     action->getObjectParams().set<std::vector<VariableName>>("e") = {_e_name};
     260          60 :     action->getObjectParams().set<std::vector<VariableName>>("v") = {_v_name};
     261          20 :     action->getObjectParams().set<UserObjectName>("fp") = _fp_1phase_name;
     262             : 
     263          60 :     _this_action_warehouse.addActionBlock(action);
     264          20 :   }
     265             : 
     266             :   // temperature
     267          20 :   addAuxVariable(_T_name);
     268             :   {
     269          20 :     const std::string class_name = "AddKernelAction";
     270          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     271          20 :     params.set<std::string>("type") = "TemperatureAux";
     272          20 :     params.set<std::string>("task") = "add_aux_kernel";
     273             : 
     274             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     275          40 :         _this_action_factory.create(class_name, _T_name + "_aux", params));
     276             : 
     277          40 :     action->getObjectParams().set<AuxVariableName>("variable") = _T_name;
     278          60 :     action->getObjectParams().set<std::vector<VariableName>>("e") = {_e_name};
     279          60 :     action->getObjectParams().set<std::vector<VariableName>>("v") = {_v_name};
     280          20 :     action->getObjectParams().set<UserObjectName>("fp") = _fp_1phase_name;
     281             : 
     282          60 :     _this_action_warehouse.addActionBlock(action);
     283          20 :   }
     284             : 
     285             :   // specific volume
     286          20 :   addAuxVariable(_v_name);
     287             :   {
     288          20 :     const std::string class_name = "AddKernelAction";
     289          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     290          20 :     params.set<std::string>("type") = "THMSpecificVolumeAux";
     291          20 :     params.set<std::string>("task") = "add_aux_kernel";
     292             : 
     293             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     294          40 :         _this_action_factory.create(class_name, _v_name + "_aux", params));
     295             : 
     296          40 :     action->getObjectParams().set<AuxVariableName>("variable") = _v_name;
     297          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoA") = {_rhoA_name};
     298          60 :     action->getObjectParams().set<std::vector<VariableName>>("A") = {_A_name};
     299             : 
     300          60 :     _this_action_warehouse.addActionBlock(action);
     301          20 :   }
     302             : 
     303             :   // specific internal energy
     304          20 :   addAuxVariable(_e_name);
     305             :   {
     306          20 :     const std::string class_name = "AddKernelAction";
     307          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     308          20 :     params.set<std::string>("type") = "THMSpecificInternalEnergyAux";
     309          20 :     params.set<std::string>("task") = "add_aux_kernel";
     310             : 
     311             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     312          40 :         _this_action_factory.create(class_name, _e_name + "_aux", params));
     313             : 
     314          40 :     action->getObjectParams().set<AuxVariableName>("variable") = _e_name;
     315          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoA") = {_rhoA_name};
     316          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhouA") = {_rhouA_name};
     317          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoEA") = {_rhoEA_name};
     318             : 
     319          60 :     _this_action_warehouse.addActionBlock(action);
     320          20 :   }
     321             : 
     322             :   // specific total enthalpy
     323          20 :   addAuxVariable(_H_name);
     324             :   {
     325          20 :     const std::string class_name = "AddKernelAction";
     326          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     327          20 :     params.set<std::string>("type") = "SpecificTotalEnthalpyAux";
     328          20 :     params.set<std::string>("task") = "add_aux_kernel";
     329             : 
     330             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     331          40 :         _this_action_factory.create(class_name, _H_name + "_aux", params));
     332             : 
     333          40 :     action->getObjectParams().set<AuxVariableName>("variable") = _H_name;
     334          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoA") = {_rhoA_name};
     335          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoEA") = {_rhoEA_name};
     336          60 :     action->getObjectParams().set<std::vector<VariableName>>("p") = {_p_name};
     337          60 :     action->getObjectParams().set<std::vector<VariableName>>("A") = {_A_name};
     338             : 
     339          60 :     _this_action_warehouse.addActionBlock(action);
     340          20 :   }
     341          20 : }
     342             : 
     343             : void
     344          20 : FlowModelSetup1Phase::addMaterials()
     345             : {
     346          20 :   FlowModelSetup::addMaterials();
     347             : 
     348          20 :   const std::string class_name = "AddMaterialAction";
     349             : 
     350             :   // unity
     351             :   {
     352          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     353          20 :     params.set<std::string>("type") = "ConstantMaterial";
     354             : 
     355             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     356          20 :         _this_action_factory.create(class_name, "unity_material", params));
     357             : 
     358          20 :     action->getObjectParams().set<std::string>("property_name") = _unity_name;
     359          20 :     action->getObjectParams().set<Real>("value") = 1.0;
     360          40 :     action->getObjectParams().set<std::vector<VariableName>>("derivative_vars") = {
     361         120 :         _rhoA_name, _rhouA_name, _rhoEA_name};
     362             : 
     363          60 :     _this_action_warehouse.addActionBlock(action);
     364          20 :   }
     365             : 
     366             :   // fluid properties
     367             :   {
     368          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     369          20 :     if (_ad)
     370           0 :       params.set<std::string>("type") = "ADFluidProperties3EqnMaterial";
     371             :     else
     372          40 :       params.set<std::string>("type") = "FluidProperties3EqnMaterial";
     373             : 
     374             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     375          40 :         _this_action_factory.create(class_name, "fluid_properties_material", params));
     376             : 
     377          60 :     action->getObjectParams().set<std::vector<VariableName>>("A") = {_A_name};
     378          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoA") = {_rhoA_name};
     379          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhouA") = {_rhouA_name};
     380          60 :     action->getObjectParams().set<std::vector<VariableName>>("rhoEA") = {_rhoEA_name};
     381             : 
     382          20 :     action->getObjectParams().set<UserObjectName>("fp") = _fp_1phase_name;
     383             : 
     384          60 :     _this_action_warehouse.addActionBlock(action);
     385          20 :   }
     386             : 
     387             :   // dynamic viscosity
     388             :   {
     389          20 :     const std::string class_name = "AddMaterialAction";
     390             : 
     391          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     392          20 :     if (_ad)
     393           0 :       params.set<std::string>("type") = "ADDynamicViscosityMaterial";
     394             :     else
     395          40 :       params.set<std::string>("type") = "DynamicViscosityMaterial";
     396             : 
     397             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     398          20 :         _this_action_factory.create(class_name, "mu_material", params));
     399             : 
     400          20 :     if (!_ad)
     401             :     {
     402          60 :       action->getObjectParams().set<std::vector<VariableName>>("arhoA") = {_rhoA_name};
     403          60 :       action->getObjectParams().set<std::vector<VariableName>>("arhouA") = {_rhouA_name};
     404          60 :       action->getObjectParams().set<std::vector<VariableName>>("arhoEA") = {_rhoEA_name};
     405             :     }
     406             : 
     407          40 :     action->getObjectParams().set<MaterialPropertyName>("mu") = {_mu_name};
     408          40 :     action->getObjectParams().set<MaterialPropertyName>("v") = {_v_name};
     409          40 :     action->getObjectParams().set<MaterialPropertyName>("e") = {_e_name};
     410          20 :     action->getObjectParams().set<UserObjectName>("fp_1phase") = _fp_1phase_name;
     411             : 
     412          60 :     _this_action_warehouse.addActionBlock(action);
     413          20 :   }
     414             : 
     415             :   // hydraulic diameter
     416             :   {
     417          20 :     InputParameters params = _this_action_factory.getValidParams(class_name);
     418          20 :     if (_ad)
     419           0 :       params.set<std::string>("type") = "ADGenericFunctionMaterial";
     420             :     else
     421          40 :       params.set<std::string>("type") = "GenericFunctionMaterial";
     422             : 
     423             :     std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
     424          20 :         _this_action_factory.create(class_name, "D_h_material", params));
     425             : 
     426          60 :     action->getObjectParams().set<std::vector<std::string>>("prop_names") = {_D_h_name};
     427          60 :     action->getObjectParams().set<std::vector<FunctionName>>("prop_values") = {_D_h_fn};
     428             : 
     429          60 :     _this_action_warehouse.addActionBlock(action);
     430          20 :   }
     431          40 : }
     432             : 
     433             : void
     434          20 : FlowModelSetup1Phase::addUserObjects()
     435             : {
     436          20 : }