TimeIntegrator.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 "MooseObject.h"
#include "Restartable.h"
#include "NonlinearTimeIntegratorInterface.h"
#include "LinearTimeIntegratorInterface.h"
 
class FEProblemBase;
class SystemBase;
class NonlinearSystemBase;
 
namespace libMesh
{
template <typename T>
class NumericVector;
} // namespace libMesh
 
class TimeIntegrator : public MooseObject,
                       public Restartable,
                       public NonlinearTimeIntegratorInterface,
                       public LinearTimeIntegratorInterface
{
public:
  static InputParameters validParams();
 
  TimeIntegrator(const InputParameters & parameters);
 
  virtual void initialSetup() {}
 
  virtual void init();
  virtual void preSolve() {}
  virtual void preStep() {}
 
  virtual void solve();
 
  virtual void postSolve() {}
 
  virtual void postStep() {}
 
  virtual int order() = 0;
 
  virtual void computeTimeDerivatives() = 0;
 
  virtual void computeADTimeDerivatives(ADReal & ad_u_dot,
                                        const dof_id_type & dof,
                                        ADReal & ad_u_dot_dot) const = 0;
 
  virtual unsigned int getNumNonlinearIterations() const { return _n_nonlinear_iterations; }
 
  virtual unsigned int getNumLinearIterations() const { return _n_linear_iterations; }
 
  const Real & dt() const { return _dt; }
 
  virtual bool isExplicit() const { return false; }
 
  /*
   * Returns whether the time integrator controls its own state. Explicit
   * methods require extra care for determing when to store old solutions and
   * stateful material properties.
   */
  virtual bool advancesProblemState() const { return false; }
 
  virtual unsigned int numStatesRequired() const { return 1; }
 
  virtual const bool & isLumped() const { return _is_lumped; }
 
  bool integratesVar(const unsigned int var_num) const;
 
  void setNumIterationsLastSolve();
 
  virtual bool overridesSolve() const = 0;
 
protected:
  unsigned int getNumNonlinearIterationsLastSolve() const;
 
  unsigned int getNumLinearIterationsLastSolve() const;
 
  void copyVector(const NumericVector<Number> & from, NumericVector<Number> & to);
 
  virtual Real duDotDuCoeff() const { return 1; }
 
  void computeDuDotDu();
 
  FEProblemBase & _fe_problem;
 
  SystemBase & _sys;
 
  std::vector<Real> & _du_dot_du;
 
  const NumericVector<Number> * const & _solution;
  const NumericVector<Number> & _solution_old;
  std::unique_ptr<NumericVector<Number>> & _solution_sub;
  std::unique_ptr<NumericVector<Number>> & _solution_old_sub;
 
  int & _t_step;
 
  Real & _dt;
 
  Real & _dt_old;
 
  unsigned int _n_nonlinear_iterations;
  unsigned int _n_linear_iterations;
 
  bool _is_lumped;
 
  bool & _var_restriction;
 
  std::vector<dof_id_type> & _local_indices;
 
  std::unordered_set<unsigned int> & _vars;
 
  std::unique_ptr<NumericVector<Number>> _from_subvector;
};