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 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();

  std::vector<unsigned int> _momentum_system_numbers;

  std::vector<LinearSystem *> _momentum_systems;

  const unsigned int _pressure_sys_number;

  LinearSystem & _pressure_system;

  const unsigned int _energy_sys_number;

  LinearSystem * _energy_system;

  const unsigned int _solid_energy_sys_number;

  LinearSystem * _solid_energy_system;

  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;


  // Handler object for CHT problems
  NS::FV::CHTHandler _cht;
};