LinearSystem.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
 
#include "SolverSystem.h"
#include "LinearFVGradientInterface.h"
#include "PerfGraphInterface.h"
#include "GradientLimiterType.h"
 
#include <set>
 
#include "libmesh/transient_system.h"
#include "libmesh/linear_implicit_system.h"
#include "libmesh/linear_solver.h"
 
class LinearFVKernel;
class InputParameters;
namespace Moose::Kokkos
{
class LinearFVKernel;
class LinearFVElementalKernel;
class LinearFVFluxKernel;
class LinearFVBoundaryCondition;
class System;
}
 
// libMesh forward declarations
namespace libMesh
{
template <typename T>
class NumericVector;
template <typename T>
class SparseMatrix;
template <typename T>
class DiagonalMatrix;
} // namespace libMesh
 
class LinearSystem : public SolverSystem,
                     public PerfGraphInterface,
                     public LinearFVGradientInterface
{
public:
  LinearSystem(FEProblemBase & problem, const std::string & name);
  virtual ~LinearSystem();
 
  virtual void solve() override;
  virtual void preInit() override;
 
  virtual bool converged() override { return _converged; }
 
  virtual void initialSetup() override;
  virtual void reinit() override;
 
#ifdef MOOSE_KOKKOS_ENABLED
  void addKokkosKernel(const std::string & kernel_name,
                       const std::string & name,
                       InputParameters & parameters);
 
  void addKokkosBoundaryCondition(const std::string & bc_name,
                                  const std::string & name,
                                  InputParameters & parameters);
#endif
 
  // Overriding these to make sure the linear systems don't do anything during
  // residual/jacobian setup
  virtual void residualSetup() override {}
  virtual void jacobianSetup() override {}
 
  virtual void stopSolve(const ExecFlagType & exec_flag,
                         const std::set<TagID> & vector_tags_to_close) override;
 
  virtual bool containsTimeKernel() override;
  virtual std::vector<std::string> timeKernelVariableNames() override { return {}; }
 
  void computeLinearSystemTags(const std::set<TagID> & vector_tags,
                               const std::set<TagID> & matrix_tags,
                               const bool compute_gradients = true);
 
  libMesh::LinearImplicitSystem & linearImplicitSystem() { return _linear_implicit_system; }
 
  NumericVector<Number> & getRightHandSideTimeVector();
 
  NumericVector<Number> & getRightHandSideNonTimeVector();
 
  virtual void augmentSparsity(SparsityPattern::Graph & sparsity,
                               std::vector<dof_id_type> & n_nz,
                               std::vector<dof_id_type> & n_oz) override;
 
  unsigned int nLinearIterations() const { return _n_linear_iters; }
 
  virtual System & system() override { return _sys; }
  virtual const System & system() const override { return _sys; }
 
  TagID rightHandSideTimeVectorTag() const { return _rhs_time_tag; }
  TagID rightHandSideNonTimeVectorTag() const { return _rhs_non_time_tag; }
  TagID rightHandSideVectorTag() const { return _rhs_tag; }
  virtual TagID systemMatrixTag() const override { return _system_matrix_tag; }
 
  NumericVector<Number> & getRightHandSideVector() { return *_linear_implicit_system.rhs; }
  const NumericVector<Number> & getRightHandSideVector() const
  {
    return *_linear_implicit_system.rhs;
  }
 
  SparseMatrix<Number> & getSystemMatrix() { return *_linear_implicit_system.matrix; }
  const SparseMatrix<Number> & getSystemMatrix() const { return *_linear_implicit_system.matrix; }
 
  using LinearFVGradientInterface::computeGradients;
  using LinearFVGradientInterface::linearFVLimitedGradientContainer;
  using LinearFVGradientInterface::requestLinearFVLimitedGradients;
 
  virtual void compute(ExecFlagType type) override;
 
protected:
  void computeLinearSystemInternal(const std::set<TagID> & vector_tags,
                                   const std::set<TagID> & matrix_tags,
                                   const bool compute_gradients = true);
 
#ifdef MOOSE_KOKKOS_ENABLED
  void initialSetupKokkosLinearFV();
 
  void computeKokkosLinearSystem(const std::set<TagID> & vector_tags,
                                 const std::set<TagID> & matrix_tags);
#endif
 
  System & _sys;
 
  unsigned int _current_l_its;
 
  std::set<TagID> _vector_tags;
 
  std::set<TagID> _matrix_tags;
 
  TagID _rhs_time_tag;
 
  NumericVector<Number> * _rhs_time;
 
  TagID _rhs_non_time_tag;
 
  NumericVector<Number> * _rhs_non_time;
 
  TagID _rhs_tag;
 
  TagID _system_matrix_non_time_tag;
 
  TagID _system_matrix_tag;
 
  unsigned int _n_linear_iters;
 
  Real _initial_linear_residual;
 
  Real _final_linear_residual;
 
  bool _converged;
 
  libMesh::LinearImplicitSystem & _linear_implicit_system;
 
private:
  std::vector<NumericVector<Number> *> _solution_state;
};