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 libMesh::NonlinearImplicitSystem::ComputePreCheck
{
public:
  NonlinearSystem(FEProblemBase & problem, const std::string & name);
  virtual ~NonlinearSystem();

  virtual void solve() override;

  virtual void preInit() 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 precheck(const NumericVector<Number> & precheck_soln,
                        NumericVector<Number> & search_direction,
                        bool & changed,
                        libMesh::NonlinearImplicitSystem & S) 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;
};