Output.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 <chrono>
 
// MOOSE includes
#include "MooseObject.h"
#include "Restartable.h"
#include "MeshChangedInterface.h"
#include "SetupInterface.h"
#include "PostprocessorInterface.h"
#include "VectorPostprocessorInterface.h"
#include "ReporterInterface.h"
#include "AdvancedOutputUtils.h"
#include "PerfGraphInterface.h"
#include "FunctionInterface.h"
 
class MooseMesh;
class Times;
 
// libMesh forward declarations
namespace libMesh
{
class EquationSystems;
}
 
class Output : public MooseObject,
               public Restartable,
               public MeshChangedInterface,
               public SetupInterface,
               public FunctionInterface,
               public PostprocessorInterface,
               public VectorPostprocessorInterface,
               public ReporterInterface,
               public PerfGraphInterface
{
public:
  static InputParameters validParams();
 
  Output(const InputParameters & parameters);
 
  virtual Real time();
 
  virtual Real timeOld();
 
  virtual Real dt();
 
  virtual Real dtOld();
 
  virtual int timeStep();
 
  const unsigned int & interval() const;
 
  const MultiMooseEnum & executeOn() const;
 
  bool isAdvanced();
 
  virtual const OutputOnWarehouse & advancedExecuteOn() const;
 
  static ExecFlagEnum getDefaultExecFlagEnum();
 
  void allowOutput(bool state) { _allow_output = state; }
 
  static void addDeprecatedInputParameters(InputParameters & params);
 
  virtual void outputStep(const ExecFlagType & type);
 
  const std::set<Real> & getSyncTimes() { return _sync_times; }
 
  virtual bool supportsMaterialPropertyOutput() const { return false; }
 
protected:
  virtual void output() = 0;
 
  virtual void solveSetup();
 
  virtual bool shouldOutput();
 
  virtual bool onInterval();
 
  void setWallTimeIntervalFromCommandLineParam();
 
  FEProblemBase * _problem_ptr;
 
  bool _transient;
 
  bool _use_displaced;
 
  libMesh::EquationSystems * _es_ptr;
 
  MooseMesh * _mesh_ptr;
 
  bool _sequence;
 
  ExecFlagEnum _execute_on;
 
  ExecFlagType _current_execute_flag;
 
  Real & _time;
 
  Real & _time_old;
 
  int & _t_step;
 
  Real & _dt;
 
  Real & _dt_old;
 
  unsigned int _num;
 
  const bool _time_step_interval_set_by_addparam;
 
  unsigned int _time_step_interval;
 
  const Real _min_simulation_time_interval;
 
  Real _wall_time_interval;
 
  std::set<Real> _sync_times;
 
  const Times * const _sync_times_object;
 
  Real _start_time;
 
  Real _end_time;
 
  int _start_step;
 
  int _end_step;
 
  Real _t_tol;
 
  bool _sync_only;
 
  bool _allow_output;
 
  bool _is_advanced;
 
  // This is here rather than in AdvancedOutput to allow generic
  // access to this data from the Console object for displaying
  // the output settings.
  OutputOnWarehouse _advanced_execute_on;
 
  Real & _last_output_simulation_time;
 
  std::chrono::time_point<std::chrono::steady_clock> _last_output_wall_time;
 
  Real _wall_time_since_last_output;
 
  friend class OutputWarehouse;
};