LinearAssemblySegregatedSolve.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
// Moose includes
#include "RhieChowMassFlux.h"
#include "SIMPLESolveBase.h"
#include "CHTHandler.h"
 
class LinearAssemblySegregatedSolve : public SIMPLESolveBase
{
public:
  LinearAssemblySegregatedSolve(Executioner & ex);
 
  static InputParameters validParams();
 
  virtual void linkRhieChowUserObject() override;
 
  virtual void initialSetup() override;
 
  virtual bool solve() override;
 
  const std::vector<LinearSystem *> systemsToSolve() const { return _systems_to_solve; }
 
protected:
  virtual std::vector<std::pair<unsigned int, Real>> solveMomentumPredictor() override;
  virtual std::pair<unsigned int, Real> solvePressureCorrector() override;
 
  virtual std::pair<unsigned int, Real> correctVelocity(const bool subtract_updated_pressure,
                                                        const bool recompute_face_mass_flux,
                                                        const SolverParams & solver_params);
 
  std::pair<unsigned int, Real>
  solveAdvectedSystem(const unsigned int system_num,
                      LinearSystem & system,
                      const Real relaxation_factor,
                      libMesh::SolverConfiguration & solver_config,
                      const Real abs_tol,
                      const bool reuse_pc,
                      const Real field_relaxation = 1.0,
                      const Real min_value_limiter = std::numeric_limits<Real>::min());
 
  struct ResidualStorage
  {
    std::vector<std::pair<unsigned int, Real>> ns_residuals;
    std::vector<Real> ns_abs_tols;
    std::vector<std::size_t> momentum_indices;
    std::size_t pressure_index = Moose::invalid_size_t;
    std::size_t energy_index = Moose::invalid_size_t;
    std::size_t solid_energy_index = Moose::invalid_size_t;
    std::vector<std::size_t> active_scalar_indices;
    std::vector<std::size_t> turbulence_indices;
    std::vector<std::size_t> pm_radiation_indices;
    bool converged = false;
  };
 
  ResidualStorage setupResidualStorage() const;
 
  std::pair<unsigned int, Real> solveSolidEnergy();
 
  void updatePressureGradient();
 
  std::vector<unsigned int> _momentum_system_numbers;
 
  std::vector<LinearSystem *> _momentum_systems;
 
  const unsigned int _momentum_pc_recompute_frequency;
 
  unsigned int _momentum_pc_solve_counter;
 
  const unsigned int _pressure_sys_number;
 
  LinearSystem & _pressure_system;
 
  const unsigned int _pressure_pc_recompute_frequency;
 
  unsigned int _pressure_pc_solve_counter;
 
  const unsigned int _energy_sys_number;
 
  LinearSystem * _energy_system;
 
  const unsigned int _energy_pc_recompute_frequency;
 
  unsigned int _energy_pc_solve_counter;
 
  const unsigned int _solid_energy_sys_number;
 
  LinearSystem * _solid_energy_system;
 
  const unsigned int _solid_energy_pc_recompute_frequency;
 
  unsigned int _solid_energy_pc_solve_counter;
 
  const unsigned int _passive_scalar_pc_recompute_frequency;
 
  unsigned int _passive_scalar_pc_solve_counter;
 
  const unsigned int _turbulence_pc_recompute_frequency;
 
  unsigned int _turbulence_pc_solve_counter;
 
  std::vector<LinearSystem *> _passive_scalar_systems;
 
  std::vector<LinearSystem *> _pm_radiation_systems;
 
  std::vector<LinearSystem *> _active_scalar_systems;
 
  std::vector<LinearSystem *> _turbulence_systems;
 
  RhieChowMassFlux * _rc_uo;
 
  std::vector<LinearSystem *> _systems_to_solve;
 
  const bool _should_solve_momentum;
  const bool _should_solve_pressure;
  const bool _should_solve_energy;
  const bool _should_solve_solid_energy;
  const bool _should_solve_turbulence;
  const bool _should_solve_passive_scalars;
  const bool _should_solve_active_scalars;
  const bool _should_solve_pm_radiation;
 
  // ************************ Active Scalar Variables ************************ //
 
  const std::vector<SolverSystemName> & _active_scalar_system_names;
 
  const bool _has_active_scalar_systems;
 
  // The number(s) of the system(s) corresponding to the active scalar equation(s)
  std::vector<unsigned int> _active_scalar_system_numbers;
 
  const std::vector<Real> _active_scalar_equation_relaxation;
 
  Moose::PetscSupport::PetscOptions _active_scalar_petsc_options;
 
  SIMPLESolverConfiguration _active_scalar_linear_control;
 
  const Real _active_scalar_l_abs_tol;
 
  const std::vector<Real> _active_scalar_absolute_tolerance;
 
  const unsigned int _active_scalar_pc_recompute_frequency;
 
  unsigned int _active_scalar_pc_solve_counter;
 
 
  // Handler object for CHT problems
  NS::FV::CHTHandler _cht;
};