multistagemethods.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
//
// SPDX-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_TIMESTEPPING_MULTISTAGE_METHODS_HH
#define DUMUX_TIMESTEPPING_MULTISTAGE_METHODS_HH
 
#include <cmath>
#include <string>
#include <array>
 
namespace Dumux::Experimental {
 
template<class Scalar>
class MultiStageMethod
{
public:
    virtual bool implicit () const = 0;
 
    virtual std::size_t numStages () const = 0;
 
    virtual Scalar temporalWeight (std::size_t i, std::size_t k) const = 0;
 
    virtual Scalar spatialWeight (std::size_t i, std::size_t k) const = 0;
 
    virtual Scalar timeStepWeight (std::size_t k) const = 0;
 
    virtual std::string name () const = 0;
 
    virtual ~MultiStageMethod() = default;
};
 
namespace MultiStage {
 
template<class Scalar>
class Theta : public MultiStageMethod<Scalar>
{
public:
    explicit Theta(const Scalar theta)
    : paramAlpha_{{-1.0, 1.0}}
    , paramBeta_{{1.0-theta, theta}}
    , paramD_{{0.0, 1.0}}
    {}
 
    bool implicit () const final
    { return paramBeta_[1] > 0.0; }
 
    std::size_t numStages () const final
    { return 1; }
 
    Scalar temporalWeight (std::size_t, std::size_t k) const final
    { return paramAlpha_[k]; }
 
    Scalar spatialWeight (std::size_t, std::size_t k) const final
    { return paramBeta_[k]; }
 
    Scalar timeStepWeight (std::size_t k) const final
    { return paramD_[k]; }
 
    std::string name () const override
    { return "theta scheme"; }
 
private:
    std::array<Scalar, 2> paramAlpha_;
    std::array<Scalar, 2> paramBeta_;
    std::array<Scalar, 2> paramD_;
};
 
template<class Scalar>
class ExplicitEuler final : public Theta<Scalar>
{
public:
    ExplicitEuler() : Theta<Scalar>(0.0) {}
 
    std::string name () const final
    { return "explicit Euler"; }
};
 
template<class Scalar>
class ImplicitEuler final : public Theta<Scalar>
{
public:
    ImplicitEuler() : Theta<Scalar>(1.0) {}
 
    std::string name () const final
    { return "implicit Euler"; }
};
 
template<class Scalar>
class RungeKuttaExplicitFourthOrder final : public MultiStageMethod<Scalar>
{
public:
    RungeKuttaExplicitFourthOrder()
    : paramAlpha_{{{-1.0, 1.0, 0.0, 0.0, 0.0},
                   {-1.0, 0.0, 1.0, 0.0, 0.0},
                   {-1.0, 0.0, 0.0, 1.0, 0.0},
                   {-1.0, 0.0, 0.0, 0.0, 1.0}}}
    , paramBeta_{{{0.5, 0.0, 0.0, 0.0, 0.0},
                  {0.0, 0.5, 0.0, 0.0, 0.0},
                  {0.0, 0.0, 1.0, 0.0, 0.0},
                  {1.0/6.0, 1.0/3.0, 1.0/3.0, 1.0/6.0, 0.0}}}
    , paramD_{{0.0, 0.5, 0.5, 1.0, 1.0}}
    {}
 
    bool implicit () const final
    { return false; }
 
    std::size_t numStages () const final
    { return 4; }
 
    Scalar temporalWeight (std::size_t i, std::size_t k) const final
    { return paramAlpha_[i-1][k]; }
 
    Scalar spatialWeight (std::size_t i, std::size_t k) const final
    { return paramBeta_[i-1][k]; }
 
    Scalar timeStepWeight (std::size_t k) const final
    { return paramD_[k]; }
 
    std::string name () const final
    { return "explicit Runge-Kutta 4th order"; }
 
private:
    std::array<std::array<Scalar, 5>, 4> paramAlpha_;
    std::array<std::array<Scalar, 5>, 4> paramBeta_;
    std::array<Scalar, 5> paramD_;
};
 
} // end namespace MultiStage
} // end namespace Dumux::Experimental
 
#endif