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;

// 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 bool converged() override { return _converged; }

  virtual void initialSetup() override;
  virtual void reinit() override;

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

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