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 "FlowChannel1Phase.h"
      11             : #include "FlowModelSinglePhase.h"
      12             : #include "SinglePhaseFluidProperties.h"
      13             : #include "MooseUtils.h"
      14             : #include "ComponentsConvergence.h"
      15             : 
      16             : registerMooseObject("ThermalHydraulicsApp", FlowChannel1Phase);
      17             : 
      18             : InputParameters
      19        8384 : FlowChannel1Phase::validParams()
      20             : {
      21        8384 :   InputParameters params = FlowChannel1PhaseBase::validParams();
      22             : 
      23       16768 :   MooseEnum wave_speed_formulation("einfeldt davis", "einfeldt");
      24       16768 :   params.addParam<MooseEnum>(
      25             :       "wave_speed_formulation", wave_speed_formulation, "Method for computing wave speeds");
      26             : 
      27        8384 :   std::vector<Real> sf_1phase(3, 1.0);
      28       16768 :   params.addParam<std::vector<Real>>(
      29             :       "scaling_factor_1phase",
      30             :       sf_1phase,
      31             :       "Scaling factors for each single phase variable (rhoA, rhouA, rhoEA)");
      32             : 
      33       16768 :   params.addParam<Real>("p_rel_step_tol", 1e-5, "Pressure relative step tolerance");
      34       16768 :   params.addParam<Real>("T_rel_step_tol", 1e-5, "Temperature relative step tolerance");
      35       16768 :   params.addParam<Real>("vel_rel_step_tol", 1e-5, "Velocity relative step tolerance");
      36       16768 :   params.addParam<Real>("mass_res_tol", 1e-5, "Mass equation normalized residual tolerance");
      37       16768 :   params.addParam<Real>(
      38       16768 :       "momentum_res_tol", 1e-5, "Momentum equation normalized residual tolerance");
      39       16768 :   params.addParam<Real>("energy_res_tol", 1e-5, "Energy equation normalized residual tolerance");
      40             : 
      41       16768 :   params.addParamNamesToGroup("scaling_factor_1phase", "Numerical scheme");
      42        8384 :   params.addClassDescription("1-phase 1D flow channel");
      43             : 
      44        8384 :   return params;
      45        8384 : }
      46             : 
      47        4191 : FlowChannel1Phase::FlowChannel1Phase(const InputParameters & params)
      48        8382 :   : FlowChannel1PhaseBase(params), _nl_conv_name(genName(name(), "nlconv"))
      49             : {
      50        4191 : }
      51             : 
      52             : void
      53        4052 : FlowChannel1Phase::checkFluidProperties() const
      54             : {
      55        4052 :   const UserObject & fp = getTHMProblem().getUserObject<UserObject>(_fp_name);
      56        4052 :   if (dynamic_cast<const SinglePhaseFluidProperties *>(&fp) == nullptr)
      57           2 :     logError("Supplied fluid properties must be for 1-phase fluids.");
      58        4052 : }
      59             : 
      60             : std::string
      61        4162 : FlowChannel1Phase::flowModelClassName() const
      62             : {
      63        4162 :   return "FlowModelSinglePhase";
      64             : }
      65             : 
      66             : std::vector<std::string>
      67        8100 : FlowChannel1Phase::ICParameters() const
      68             : {
      69        8100 :   return {"initial_p", "initial_T", "initial_vel"};
      70             : }
      71             : 
      72             : void
      73        4052 : FlowChannel1Phase::check() const
      74             : {
      75        4052 :   FlowChannel1PhaseBase::check();
      76        4052 :   checkScalingFactors();
      77        4052 : }
      78             : 
      79             : void
      80        4052 : FlowChannel1Phase::checkScalingFactors() const
      81             : {
      82             :   // If using ComponentsConvergence, make sure that all residual scaling factors
      83             :   // are set to one, since a normalized residual norm is used.
      84        4052 :   const auto & conv_names = getTHMProblem().getNonlinearConvergenceNames();
      85             :   mooseAssert(conv_names.size() == 1, "There must be exactly one nonlinear convergence object.");
      86        4052 :   if (dynamic_cast<ComponentsConvergence *>(&getTHMProblem().getConvergence(conv_names[0])))
      87             :   {
      88          42 :     const auto & scaling_factors = getParam<std::vector<Real>>("scaling_factor_1phase");
      89             :     bool all_are_one = true;
      90          84 :     for (const auto factor : scaling_factors)
      91          63 :       if (!MooseUtils::absoluteFuzzyEqual(factor, 1.0))
      92             :         all_are_one = false;
      93          21 :     if (!all_are_one)
      94           2 :       logError("When using ComponentsConvergence, 'scaling_factor_1phase' must be set to '1 1 1'.");
      95             :   }
      96        4052 : }
      97             : 
      98             : void
      99        4048 : FlowChannel1Phase::addMooseObjects()
     100             : {
     101        4048 :   FlowChannel1PhaseBase::addMooseObjects();
     102        4048 :   addNonlinearConvergence();
     103        4048 : }
     104             : 
     105             : void
     106        4048 : FlowChannel1Phase::addNonlinearConvergence()
     107             : {
     108        4048 :   const std::string class_name = "FlowChannel1PhaseConvergence";
     109        4048 :   InputParameters params = _factory.getValidParams(class_name);
     110       16192 :   params.set<PostprocessorName>("p_rel_step") = genName(name(), "p_rel_step");
     111       16192 :   params.set<PostprocessorName>("T_rel_step") = genName(name(), "T_rel_step");
     112       16192 :   params.set<PostprocessorName>("vel_rel_step") = genName(name(), "vel_rel_step");
     113       16192 :   params.set<PostprocessorName>("mass_res") = genName(name(), "mass_res");
     114       16192 :   params.set<PostprocessorName>("momentum_res") = genName(name(), "momentum_res");
     115       16192 :   params.set<PostprocessorName>("energy_res") = genName(name(), "energy_res");
     116        4048 :   params.applyParameters(parameters());
     117        4048 :   getTHMProblem().addConvergence(class_name, _nl_conv_name, params);
     118        8096 : }
     119             : 
     120             : Convergence *
     121          22 : FlowChannel1Phase::getNonlinearConvergence() const
     122             : {
     123          22 :   return &getTHMProblem().getConvergence(_nl_conv_name);
     124             : }