TransientBase.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 "Executioner.h"
#include "TimeIntegrator.h"
 
// System includes
#include <string>
#include <fstream>
#include <optional>
 
class TimeStepper;
class FEProblemBase;
 
class TransientBase : public Executioner
{
public:
  static InputParameters defaultSteadyStateConvergenceParams();
  static InputParameters validParams();
 
  TransientBase(const InputParameters & parameters);
 
  virtual void init() override;
 
  virtual void execute() override;
 
  virtual void takeStep(Real input_dt = -1.0);
 
  virtual Real computeConstrainedDT();
  virtual void estimateTimeError();
 
  virtual Real getDT();
 
  virtual bool keepGoing();
 
  virtual bool lastSolveConverged() const override;
 
  virtual void preExecute() override;
 
  virtual void postExecute() override;
 
  void computeDT();
 
  virtual void preStep();
 
  virtual void postStep();
 
  virtual void incrementStepOrReject();
 
  virtual void endStep(Real input_time = -1.0);
 
  virtual void setTargetTime(Real target_time);
 
  virtual Real getTime() const { return _time; };
 
  virtual Real getTargetTime() { return _target_time; }
 
  virtual void setTime(Real t) { _time = t; };
 
  virtual void setTimeOld(Real t) { _time_old = t; };
 
  Real computeSolutionChangeNorm(bool check_aux, bool normalize_by_dt) const;
 
  virtual Real relativeSolutionDifferenceNorm(bool check_aux) const = 0;
 
  TimeStepper * getTimeStepper() { return _time_stepper; }
  const TimeStepper * getTimeStepper() const { return _time_stepper; }
 
  void setTimeStepper(TimeStepper & ts);
 
  virtual std::string getTimeStepperName() const override;
 
  virtual std::set<TimeIntegrator *> getTimeIntegrators() const = 0;
 
  virtual std::vector<std::string> getTimeIntegratorNames() const override;
 
  Moose::TimeIntegratorType getTimeScheme() const { return _time_scheme; }
 
  std::set<Real> & syncTimes() { return _sync_times; }
 
  Real & dtMax() { return _dtmax; }
 
  Real & dtMin() { return _dtmin; }
 
  Real getStartTime() const { return _start_time; }
 
  Real getEndTime() const { return _end_time; }
 
  Real & endTime() { return _end_time; }
 
  Real & timestepTol() { return _timestep_tolerance; }
 
  virtual void setTimestepTolerance(const Real & tolerance) { _timestep_tolerance = tolerance; }
 
  bool atSyncPoint() { return _at_sync_point; }
 
  Real unconstrainedDT() { return _unconstrained_dt; }
 
  void parentOutputPositionChanged() override;
 
  virtual void forceNumSteps(const unsigned int num_steps) { _num_steps = num_steps; }
 
  virtual SolveObject * timeStepSolveObject() { return _fixed_point_solve.get(); }
 
  bool convergedToSteadyState() const;
 
protected:
  FEProblemBase & _problem;
 
  AuxiliarySystem & _aux;
 
  Moose::TimeIntegratorType _time_scheme;
  TimeStepper * _time_stepper;
 
  int & _t_step;
  Real & _time;
  Real & _time_old;
  Real & _dt;
  Real & _dt_old;
 
  Real & _unconstrained_dt;
  bool & _at_sync_point;
 
  bool & _last_solve_converged;
 
  bool _xfem_repeat_step;
 
  Real _end_time;
  Real _dtmin;
  Real _dtmax;
  unsigned int _num_steps;
  int _n_startup_steps;
 
  const bool _steady_state_detection;
  const Real _steady_state_start_time;
 
  std::set<Real> & _sync_times;
 
  bool _abort;
  const bool _error_on_dtmin;
 
  bool & _time_interval;
  Real _next_interval_output_time;
  Real _time_interval_output_interval;
 
  Real _start_time;
  Real _timestep_tolerance;
  Real & _target_time;
  bool _use_multiapp_dt;
 
  void setupTimeIntegrator();
 
private:
  void constrainDTFromMultiApp(Real & dt_cur,
                               std::ostringstream & diag,
                               const ExecFlagType & execute_on) const;
 
  std::optional<int> _test_restep_step;
  std::optional<Real> _test_restep_time;
  bool _testing_restep;
};