RiemannConfig.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once

 
#include "shambackends/type_traits.hpp"
#include "shambackends/vec.hpp"
#include "shamsys/legacy/log.hpp"
#include <nlohmann/json.hpp>
#include <variant>
 
namespace shammodels::gsph {

    template<class Tvec>
    struct RiemannConfig;
 
} // namespace shammodels::gsph
 
template<class Tvec>
struct shammodels::gsph::RiemannConfig {
 
    using Tscal              = shambase::VecComponent<Tvec>;
    static constexpr u32 dim = shambase::VectorProperties<Tvec>::dimension;

    struct Iterative {
        Tscal tol    = Tscal{1.0e-6}; 
        u32 max_iter = 20;            
    };

    struct Exact {
        Tscal tol    = Tscal{1.0e-8}; 
        u32 max_iter = 100;           
    };

    struct HLLC {};

    struct Roe {
        Tscal entropy_fix = Tscal{0.1}; 
    };
 
    using Variant = std::variant<Iterative, Exact, HLLC, Roe>;
 
    Variant config = Iterative{};
 
    void set(Variant v) { config = v; }
 
    void set_iterative(Tscal tol = Tscal{1.0e-6}, u32 max_iter = 20) {
        set(Iterative{tol, max_iter});
    }
 
    void set_exact(Tscal tol = Tscal{1.0e-8}, u32 max_iter = 100) { set(Exact{tol, max_iter}); }
 
    void set_hllc() { set(HLLC{}); }
 
    void set_roe(Tscal entropy_fix = Tscal{0.1}) { set(Roe{entropy_fix}); }
 
    inline bool is_iterative() const { return std::holds_alternative<Iterative>(config); }
    inline bool is_exact() const { return std::holds_alternative<Exact>(config); }
    inline bool is_hllc() const { return std::holds_alternative<HLLC>(config); }
    inline bool is_roe() const { return std::holds_alternative<Roe>(config); }
 
    inline void print_status() const {
        logger::raw_ln("--- Riemann solver config");
 
        if (const Iterative *v = std::get_if<Iterative>(&config)) {
            logger::raw_ln("  Type     : Iterative (van Leer 1997)");
            logger::raw_ln("  tol      =", v->tol);
            logger::raw_ln("  max_iter =", v->max_iter);
        } else if (const Exact *v = std::get_if<Exact>(&config)) {
            logger::raw_ln("  Type     : Exact (Toro)");
            logger::raw_ln("  tol      =", v->tol);
            logger::raw_ln("  max_iter =", v->max_iter);
        } else if (std::get_if<HLLC>(&config)) {
            logger::raw_ln("  Type : HLLC");
        } else if (const Roe *v = std::get_if<Roe>(&config)) {
            logger::raw_ln("  Type        : Roe");
            logger::raw_ln("  entropy_fix =", v->entropy_fix);
        } else {
            shambase::throw_unimplemented();
        }
 
        logger::raw_ln("-------------");
    }
};
 
namespace shammodels::gsph {
 
    template<class Tvec>
    inline void to_json(nlohmann::json &j, const RiemannConfig<Tvec> &p) {
        using T         = RiemannConfig<Tvec>;
        using Iterative = typename T::Iterative;
        using Exact     = typename T::Exact;
        using HLLC      = typename T::HLLC;
        using Roe       = typename T::Roe;
 
        if (const Iterative *v = std::get_if<Iterative>(&p.config)) {
            j = {
                {"riemann_type", "iterative"},
                {"tol", v->tol},
                {"max_iter", v->max_iter},
            };
        } else if (const Exact *v = std::get_if<Exact>(&p.config)) {
            j = {
                {"riemann_type", "exact"},
                {"tol", v->tol},
                {"max_iter", v->max_iter},
            };
        } else if (std::get_if<HLLC>(&p.config)) {
            j = {
                {"riemann_type", "hllc"},
            };
        } else if (const Roe *v = std::get_if<Roe>(&p.config)) {
            j = {
                {"riemann_type", "roe"},
                {"entropy_fix", v->entropy_fix},
            };
        } else {
            shambase::throw_unimplemented();
        }
    }
 
    template<class Tvec>
    inline void from_json(const nlohmann::json &j, RiemannConfig<Tvec> &p) {
        using T     = RiemannConfig<Tvec>;
        using Tscal = shambase::VecComponent<Tvec>;
 
        if (!j.contains("riemann_type")) {
            shambase::throw_with_loc<std::runtime_error>(
                "no field riemann_type is found in this json");
        }
 
        std::string riemann_type;
        j.at("riemann_type").get_to(riemann_type);
 
        using Iterative = typename T::Iterative;
        using Exact     = typename T::Exact;
        using HLLC      = typename T::HLLC;
        using Roe       = typename T::Roe;
 
        if (riemann_type == "iterative") {
            p.set(Iterative{j.at("tol").get<Tscal>(), j.at("max_iter").get<u32>()});
        } else if (riemann_type == "exact") {
            // max_iter is read with a fallback default so configs saved before
            // this field existed (tol-only) still load instead of throwing.
            p.set(Exact{j.at("tol").get<Tscal>(), j.value("max_iter", Exact{}.max_iter)});
        } else if (riemann_type == "hllc") {
            p.set(HLLC{});
        } else if (riemann_type == "roe") {
            p.set(Roe{j.at("entropy_fix").get<Tscal>()});
        } else {
            shambase::throw_unimplemented("Unknown Riemann solver type: " + riemann_type);
        }
    }
 
} // namespace shammodels::gsph