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