rungeKutta.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2025 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#if NN_WITH_SUNDIALS
 
#include <functional>
#include <memory>
 
#include "NeoN/core/database/fieldCollection.hpp"
#include "NeoN/core/database/oldTimeCollection.hpp"
#include "NeoN/core/parallelAlgorithms.hpp"
#include "NeoN/fields/field.hpp"
#include "NeoN/timeIntegration/timeIntegration.hpp"
#include "NeoN/timeIntegration/sundials.hpp"
 
 
namespace NeoN::timeIntegration
{
 
template<typename SolutionVectorType>
class RungeKutta :
    public TimeIntegratorBase<SolutionVectorType>::template Register<RungeKutta<SolutionVectorType>>
{
public:
 
    using ValueType = typename SolutionVectorType::VectorValueType;
    using Base =
        TimeIntegratorBase<SolutionVectorType>::template Register<RungeKutta<SolutionVectorType>>;
 
    RungeKutta() = default;
 
    ~RungeKutta() = default;
 
    RungeKutta(const Dictionary& schemeDict, const Dictionary& solutionDict)
        : Base(schemeDict, solutionDict)
    {}
 
    RungeKutta(const RungeKutta& other);
 
    RungeKutta(RungeKutta&& other);
 
    // deleted because base class method deleted.
    RungeKutta& operator=(const RungeKutta& other) = delete;
 
    // deleted because base class method deleted.
    RungeKutta& operator=(RungeKutta&& other) = delete;
 
    static std::string name() { return "Runge-Kutta"; }
 
    static std::string doc() { return "Explicit time integration using the Runge-Kutta method."; }
 
    static std::string schema() { return "none"; }
 
    void solve(
        dsl::Expression<ValueType>& exp,
        SolutionVectorType& solutionVector,
        scalar t,
        const scalar dt
    ) override;
 
    std::unique_ptr<TimeIntegratorBase<SolutionVectorType>> clone() const override;
 
 
private:
 
    NeoN::sundials::SKVector<ValueType>
        solution_; 
    NeoN::sundials::SKVector<ValueType>
        initialConditions_; 
    std::shared_ptr<SUNContext> context_ {
        nullptr, sundials::SUN_CONTEXT_DELETER
    }; 
    std::unique_ptr<char, decltype(sundials::SUN_ARK_DELETER)> ODEMemory_ {
        nullptr, sundials::SUN_ARK_DELETER
    }; 
    std::unique_ptr<NeoN::dsl::Expression<ValueType>> pdeExpr_ {nullptr
    }; 
    void
    initSUNERKSolver(dsl::Expression<ValueType>& exp, SolutionVectorType& field, const scalar t);
 
    void initExpression(const dsl::Expression<ValueType>& exp);
 
    void initSUNContext();
 
    void initSUNVector(const Executor& exec, size_t size);
 
    void initSUNInitialConditions(const SolutionVectorType& solutionVector);
 
    void initODEMemory(const scalar t);
};
 
} // namespace NeoN
 
#endif