explicit_timesteppers.h

Go to the documentation of this file.

// LIC// ====================================================================
// LIC// This file forms part of oomph-lib, the object-oriented,
// LIC// multi-physics finite-element library, available
// LIC// at http://www.oomph-lib.org.
// LIC//
// LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel
// LIC//
// LIC// This library is free software; you can redistribute it and/or
// LIC// modify it under the terms of the GNU Lesser General Public
// LIC// License as published by the Free Software Foundation; either
// LIC// version 2.1 of the License, or (at your option) any later version.
// LIC//
// LIC// This library is distributed in the hope that it will be useful,
// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// LIC// Lesser General Public License for more details.
// LIC//
// LIC// You should have received a copy of the GNU Lesser General Public
// LIC// License along with this library; if not, write to the Free Software
// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// LIC// 02110-1301  USA.
// LIC//
// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
// LIC//
// LIC//====================================================================
// Header functions for classes that represent explicit time-stepping schemes
 
// Include guards to prevent multiple inclusion of this header
#ifndef OOMPH_EXPLICIT_TIMESTEPPERS
#define OOMPH_EXPLICIT_TIMESTEPPERS
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
 
#ifdef OOMPH_HAS_MPI
#include "mpi.h"
#endif
 
#include "Vector.h"
#include "double_vector.h"
#include "oomph_utilities.h"
 
namespace oomph
{
  class Time;
 
  //===============================================================
  //===============================================================
  class ExplicitTimeSteppableObject
  {
    // Dummy double value for time
    static double Dummy_time_value;
 
  public:
    ExplicitTimeSteppableObject() {}
 
    ExplicitTimeSteppableObject(const ExplicitTimeSteppableObject&) = delete;
 
    void operator=(const ExplicitTimeSteppableObject&) = delete;
 
    virtual ~ExplicitTimeSteppableObject() {}
 
    virtual void get_dvaluesdt(DoubleVector& minv_res);
 
    virtual void get_dofs(DoubleVector& dofs) const;
 
    virtual void get_dofs(const unsigned& t, DoubleVector& dofs) const;
 
    virtual void set_dofs(const DoubleVector& dofs);
 
    virtual void add_to_dofs(const double& lambda,
                             const DoubleVector& increment_dofs);
 
    virtual void actions_before_explicit_stage() {}
 
    virtual void actions_after_explicit_stage() {}
 
    virtual void actions_before_explicit_timestep() {}
 
    virtual void actions_after_explicit_timestep() {}
 
    virtual double& time();
 
    virtual Time* time_pt() const;
  };
 
 
  //=====================================================================
  //=====================================================================
  class ExplicitTimeStepper
  {
  protected:
    std::string Type;
 
  public:
    ExplicitTimeStepper() {}
 
    ExplicitTimeStepper(const ExplicitTimeStepper&) = delete;
 
    void operator=(const ExplicitTimeStepper&) = delete;
 
    virtual ~ExplicitTimeStepper() {}
 
    // referenced by object_pt by an amount dt
    virtual void timestep(ExplicitTimeSteppableObject* const& object_pt,
                          const double& dt) = 0;
  };
 
 
  //============================================================
  class Euler : public ExplicitTimeStepper
  {
  public:
    Euler()
    {
      Type = "Euler";
    }
 
    Euler(const Euler&) = delete;
 
    void operator=(const Euler&) = delete;
 
    void timestep(ExplicitTimeSteppableObject* const& object_pt,
                  const double& dt);
  };
 
  //============================================================
  template<unsigned ORDER>
  class RungeKutta : public ExplicitTimeStepper
  {
  public:
    RungeKutta()
    {
      Type = "RungeKutta";
    }
 
    RungeKutta(const RungeKutta&) = delete;
 
    void operator=(const RungeKutta&) = delete;
 
    // reference by object_pt by an amount dt
    void timestep(ExplicitTimeSteppableObject* const& object_pt,
                  const double& dt);
  };
 
 
  //============================================================
  template<unsigned ORDER>
  class LowStorageRungeKutta : public ExplicitTimeStepper
  {
    // Storage for the coefficients
    Vector<double> A, B, C;
 
  public:
    LowStorageRungeKutta();
 
    LowStorageRungeKutta(const LowStorageRungeKutta&) = delete;
 
    void operator=(const LowStorageRungeKutta&) = delete;
 
    void timestep(ExplicitTimeSteppableObject* const& object_pt,
                  const double& dt);
  };
 
 
  //============================================================
  class EBDF3 : public ExplicitTimeStepper
  {
    double Yn_weight;
    double Ynm1_weight;
    double Ynm2_weight;
    double Fn_weight;
 
  public:
    EBDF3() {}
 
    EBDF3(const EBDF3&) = delete;
 
    void operator=(const EBDF3&) = delete;
 
    void set_weights(const double& dtn,
                     const double& dtnm1,
                     const double& dtnm2);
 
    void timestep(ExplicitTimeSteppableObject* const& object_pt,
                  const double& dt);
  };
 
} // namespace oomph
 
#endif