theta_timestepping.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2010 - 2023 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_theta_timestepping_h
#define dealii_theta_timestepping_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/algorithms/operator.h>
#include <deal.II/algorithms/timestep_control.h>
 
#include <deal.II/base/observer_pointer.h>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declaration
#ifndef DOXYGEN
class ParameterHandler;
#endif
 
namespace Algorithms
{
  struct TimestepData
  {
    double time;
    double step;
  };
 
  template <typename VectorType>
  class ThetaTimestepping : public OperatorBase
  {
  public:
    ThetaTimestepping(OperatorBase &op_explicit, OperatorBase &op_implicit);
 
    virtual void
    operator()(AnyData &out, const AnyData &in) override;
 
    virtual void
    notify(const Event &) override;
 
    void
    set_output(OutputOperator<VectorType> &output);
 
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
 
    double
    current_time() const;
 
    double
    theta() const;
 
    double
    theta(double new_theta);
 
    const TimestepData &
    explicit_data() const;
 
    const TimestepData &
    implicit_data() const;
 
    TimestepControl &
    timestep_control();
 
  private:
    TimestepControl control;
 
    double vtheta;
    bool adaptive;
 
    TimestepData d_explicit;
 
    TimestepData d_implicit;
 
 
    ObserverPointer<OperatorBase, ThetaTimestepping<VectorType>> op_explicit;
 
    ObserverPointer<OperatorBase, ThetaTimestepping<VectorType>> op_implicit;
 
    ObserverPointer<OutputOperator<VectorType>, ThetaTimestepping<VectorType>>
      output;
  };
 
 
  template <typename VectorType>
  inline const TimestepData &
  ThetaTimestepping<VectorType>::explicit_data() const
  {
    return d_explicit;
  }
 
 
  template <typename VectorType>
  inline const TimestepData &
  ThetaTimestepping<VectorType>::implicit_data() const
  {
    return d_implicit;
  }
 
 
  template <typename VectorType>
  inline TimestepControl &
  ThetaTimestepping<VectorType>::timestep_control()
  {
    return control;
  }
 
  template <typename VectorType>
  inline void
  ThetaTimestepping<VectorType>::set_output(OutputOperator<VectorType> &out)
  {
    output = &out;
  }
 
 
  template <typename VectorType>
  inline double
  ThetaTimestepping<VectorType>::theta() const
  {
    return vtheta;
  }
 
 
  template <typename VectorType>
  inline double
  ThetaTimestepping<VectorType>::theta(double new_theta)
  {
    const double tmp = vtheta;
    vtheta           = new_theta;
    return tmp;
  }
 
 
  template <typename VectorType>
  inline double
  ThetaTimestepping<VectorType>::current_time() const
  {
    return control.now();
  }
} // namespace Algorithms
 
DEAL_II_NAMESPACE_CLOSE
 
#endif