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