discrete_time.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2020 - 2022 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_discrete_time_h
#define dealii_discrete_time_h
 
#include <deal.II/base/config.h>
 
DEAL_II_NAMESPACE_OPEN
 
class DiscreteTime
{
public:
  DiscreteTime(const double start_time,
               const double end_time,
               const double desired_start_step_size = 0.);
 
  double
  get_current_time() const;
 
  double
  get_next_time() const;
 
  double
  get_previous_time() const;
 
  double
  get_start_time() const;
 
  double
  get_end_time() const;
 
  bool
  is_at_start() const;
 
  bool
  is_at_end() const;
 
  double
  get_next_step_size() const;
 
  double
  get_previous_step_size() const;
 
  unsigned int
  get_step_number() const;
 
  void
  set_desired_next_step_size(const double time_step_size);
 
  void
  set_next_step_size(const double time_step_size);
 
  void
  advance_time();
 
  void
  restart();
 
  std::size_t
  memory_consumption() const;
 
  template <class Archive>
  void
  serialize(Archive &ar, const unsigned int version);
 
private:
  double start_time;
 
  double end_time;
 
  double current_time;
 
  double next_time;
 
  double previous_time;
 
  double start_step_size;
 
  unsigned int step_number;
};
 
 
/*---------------------- Inline functions ------------------------------*/
 
 
inline double
DiscreteTime::get_start_time() const
{
  return start_time;
}
 
 
 
inline double
DiscreteTime::get_end_time() const
{
  return end_time;
}
 
 
 
inline bool
DiscreteTime::is_at_start() const
{
  return step_number == 0;
}
 
 
 
inline bool
DiscreteTime::is_at_end() const
{
  return current_time == end_time;
}
 
 
 
inline double
DiscreteTime::get_next_step_size() const
{
  return next_time - current_time;
}
 
 
 
inline double
DiscreteTime::get_previous_step_size() const
{
  return current_time - previous_time;
}
 
 
 
inline double
DiscreteTime::get_current_time() const
{
  return current_time;
}
 
 
 
inline double
DiscreteTime::get_next_time() const
{
  return next_time;
}
 
 
 
inline double
DiscreteTime::get_previous_time() const
{
  return previous_time;
}
 
 
 
inline unsigned int
DiscreteTime::get_step_number() const
{
  return step_number;
}
 
 
 
template <class Archive>
inline void
DiscreteTime::serialize(Archive &ar, const unsigned int)
{
  ar &start_time;
  ar &end_time;
  ar &current_time;
  ar &next_time;
  ar &previous_time;
  ar &start_step_size;
  ar &step_number;
}
 
DEAL_II_NAMESPACE_CLOSE
 
#endif