NonlinearSystem.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 "NonlinearSystemBase.h"
#include "ComputeResidualFunctor.h"
#include "ComputeFDResidualFunctor.h"
#include "ComputeResidualAndJacobian.h"
#include "SubProblem.h"
#include "MooseError.h"
 
#include "libmesh/transient_system.h"
#include "libmesh/nonlinear_implicit_system.h"
 
class NonlinearSystem : public NonlinearSystemBase
{
public:
  NonlinearSystem(FEProblemBase & problem, const std::string & name);
  virtual ~NonlinearSystem();
 
  virtual void solve() override;
 
  virtual void stopSolve(const ExecFlagType & exec_flag,
                         const std::set<TagID> & vector_tags_to_close) override;
 
  virtual unsigned int getCurrentNonlinearIterationNumber() override
  {
    return _nl_implicit_sys.get_current_nonlinear_iteration_number();
  }
 
  virtual void setupFiniteDifferencedPreconditioner() override;
 
  virtual bool converged() override;
 
  virtual NumericVector<Number> & RHS() override { return *_nl_implicit_sys.rhs; }
 
  virtual libMesh::NonlinearSolver<Number> * nonlinearSolver() override
  {
    return _nl_implicit_sys.nonlinear_solver.get();
  }
 
  virtual SNES getSNES() override;
 
  virtual libMesh::NonlinearImplicitSystem & sys() { return _nl_implicit_sys; }
 
  virtual void attachPreconditioner(libMesh::Preconditioner<Number> * preconditioner) override;
 
  virtual void residualAndJacobianTogether() override;
 
  virtual void potentiallySetupFiniteDifferencing() override;
 
protected:
  void computeScalingJacobian() override;
  void computeScalingResidual() override;
 
  libMesh::NonlinearImplicitSystem & _nl_implicit_sys;
  ComputeResidualFunctor _nl_residual_functor;
  ComputeFDResidualFunctor _fd_residual_functor;
  ComputeResidualAndJacobian _resid_and_jac_functor;
 
private:
  void setupStandardFiniteDifferencedPreconditioner();
 
  void setupColoringFiniteDifferencedPreconditioner();
 
  virtual bool matrixFromColoring() const override { return _use_coloring_finite_difference; }
 
  bool _use_coloring_finite_difference;
};