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:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   This program is free software: you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
 *   the Free Software Foundation, either version 3 of the License, or       *
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
#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