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>

class TimeStepper;
class FEProblemBase;

class TransientBase : public Executioner
{
public:
  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;

  virtual 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 getSolutionChangeNorm();

  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 Real relativeSolutionDifferenceNorm() = 0;

  virtual void forceNumSteps(const unsigned int num_steps) { _num_steps = num_steps; }

  virtual SolveObject * timeStepSolveObject() { return _fixed_point_solve.get(); }

protected:
  FEProblemBase & _problem;

  AuxiliarySystem & _aux;

  const bool _check_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;

  bool _steady_state_detection;
  Real _steady_state_tolerance;
  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;

  Real & _solution_change_norm;

  void setupTimeIntegrator();

  const bool _normalize_solution_diff_norm_by_dt;

  bool convergedToSteadyState() const;

private:
  void constrainDTFromMultiApp(Real & dt_cur,
                               std::ostringstream & diag,
                               const ExecFlagType & execute_on) const;
};