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"

class LinearAssemblySegregatedSolve : public SIMPLESolveBase
{
public:
  LinearAssemblySegregatedSolve(Executioner & ex);

  static InputParameters validParams();

  virtual void linkRhieChowUserObject() 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);

  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 *> _active_scalar_systems;

  RhieChowMassFlux * _rc_uo;

  std::vector<LinearSystem *> _systems_to_solve;

  // ************************ 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;
};