AVConfig.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 "shamrock/io/json_variant.hpp"
#include "shamsys/legacy/log.hpp"
#include <nlohmann/json.hpp>
#include <variant>
 
namespace shammodels::sph {
 
    template<class Tscal>
    struct AVConfig_None {
        static constexpr std::string_view variant_type_name = "none";
    };
 
    template<class Tscal>
    inline void to_json(nlohmann::json &j, const AVConfig_None<Tscal> &p) {}
 
    template<class Tscal>
    inline void from_json(const nlohmann::json &j, AVConfig_None<Tscal> &p) {
        p = {};
    }
 
    template<class Tscal>
    struct AVConfig_Constant {
        static constexpr std::string_view variant_type_name = "constant";
 
        Tscal alpha_u  = 1.0;
        Tscal alpha_AV = 1.0;
        Tscal beta_AV  = 2.0;
    };
 
    template<class Tscal>
    inline void to_json(nlohmann::json &j, const AVConfig_Constant<Tscal> &p) {
        j = {
            {"alpha_u", p.alpha_u},
            {"alpha_AV", p.alpha_AV},
            {"beta_AV", p.beta_AV},
        };
    }
 
    template<class Tscal>
    inline void from_json(const nlohmann::json &j, AVConfig_Constant<Tscal> &p) {
        j.at("alpha_u").get_to(p.alpha_u);
        j.at("alpha_AV").get_to(p.alpha_AV);
        j.at("beta_AV").get_to(p.beta_AV);
    }
 
    template<class Tscal>
    struct AVConfig_VaryingMM97 {
        static constexpr std::string_view variant_type_name = "varying_mm97";
 
        Tscal alpha_min   = 0.1;
        Tscal alpha_max   = 1.0;
        Tscal sigma_decay = 0.1;
        Tscal alpha_u     = 1.0;
        Tscal beta_AV     = 2.0;
    };
 
    template<class Tscal>
    inline void to_json(nlohmann::json &j, const AVConfig_VaryingMM97<Tscal> &p) {
        j = {
            {"alpha_min", p.alpha_min},
            {"alpha_max", p.alpha_max},
            {"sigma_decay", p.sigma_decay},
            {"alpha_u", p.alpha_u},
            {"beta_AV", p.beta_AV},
        };
    }
 
    template<class Tscal>
    inline void from_json(const nlohmann::json &j, AVConfig_VaryingMM97<Tscal> &p) {
        j.at("alpha_min").get_to(p.alpha_min);
        j.at("alpha_max").get_to(p.alpha_max);
        j.at("sigma_decay").get_to(p.sigma_decay);
        j.at("alpha_u").get_to(p.alpha_u);
        j.at("beta_AV").get_to(p.beta_AV);
    }
 
    template<class Tscal>
    struct AVConfig_VaryingCD10 {
        static constexpr std::string_view variant_type_name = "varying_cd10";
 
        Tscal alpha_min   = 0.1;
        Tscal alpha_max   = 1.0;
        Tscal sigma_decay = 0.1;
        Tscal alpha_u     = 1.0;
        Tscal beta_AV     = 2.0;
    };
 
    template<class Tscal>
    inline void to_json(nlohmann::json &j, const AVConfig_VaryingCD10<Tscal> &p) {
        j = {
            {"alpha_min", p.alpha_min},
            {"alpha_max", p.alpha_max},
            {"sigma_decay", p.sigma_decay},
            {"alpha_u", p.alpha_u},
            {"beta_AV", p.beta_AV},
        };
    }
 
    template<class Tscal>
    inline void from_json(const nlohmann::json &j, AVConfig_VaryingCD10<Tscal> &p) {
        j.at("alpha_min").get_to(p.alpha_min);
        j.at("alpha_max").get_to(p.alpha_max);
        j.at("sigma_decay").get_to(p.sigma_decay);
        j.at("alpha_u").get_to(p.alpha_u);
        j.at("beta_AV").get_to(p.beta_AV);
    }
 
    template<class Tscal>
    struct AVConfig_ConstantDisc {
        static constexpr std::string_view variant_type_name = "constant_disc";
 
        Tscal alpha_AV = 1.0;
        Tscal alpha_u  = 1.0;
        Tscal beta_AV  = 2.0;
    };
 
    template<class Tscal>
    inline void to_json(nlohmann::json &j, const AVConfig_ConstantDisc<Tscal> &p) {
        j = {
            {"alpha_AV", p.alpha_AV},
            {"alpha_u", p.alpha_u},
            {"beta_AV", p.beta_AV},
        };
    }
 
    template<class Tscal>
    inline void from_json(const nlohmann::json &j, AVConfig_ConstantDisc<Tscal> &p) {
        j.at("alpha_AV").get_to(p.alpha_AV);
        j.at("alpha_u").get_to(p.alpha_u);
        j.at("beta_AV").get_to(p.beta_AV);
    }
 
    template<class Tvec>
    struct AVConfig;
} // namespace shammodels::sph
 
template<class Tvec>
struct shammodels::sph::AVConfig {
 
    using Tscal = shambase::VecComponent<Tvec>;
    static constexpr u32 dim = shambase::VectorProperties<Tvec>::dimension;
 
    using None         = AVConfig_None<Tscal>;
    using Constant     = AVConfig_Constant<Tscal>;
    using VaryingMM97  = AVConfig_VaryingMM97<Tscal>;
    using VaryingCD10  = AVConfig_VaryingCD10<Tscal>;
    using ConstantDisc = AVConfig_ConstantDisc<Tscal>;
 
    using Variant = std::variant<None, Constant, VaryingMM97, VaryingCD10, ConstantDisc>;
 
    Variant config = Constant{};
 
    void set(Variant v) { config = v; }
 
    void set_varying_cd10(
        Tscal alpha_min, Tscal alpha_max, Tscal sigma_decay, Tscal alpha_u, Tscal beta_AV) {
        set(VaryingCD10{alpha_min, alpha_max, sigma_decay, alpha_u, beta_AV});
    }
 
    inline bool has_alphaAV_field() {
        bool is_varying_alpha
            = bool(std::get_if<VaryingMM97>(&config)) || bool(std::get_if<VaryingCD10>(&config));
        return is_varying_alpha;
    }
 
    inline bool has_divv_field() {
        bool is_varying_alpha
            = bool(std::get_if<VaryingMM97>(&config)) || bool(std::get_if<VaryingCD10>(&config));
        return is_varying_alpha;
    }
 
    inline bool has_curlv_field() {
        bool is_varying_alpha = bool(std::get_if<VaryingCD10>(&config));
        return is_varying_alpha;
    }
 
    inline bool has_dtdivv_field() {
        bool is_varying_alpha = bool(std::get_if<VaryingCD10>(&config));
        return is_varying_alpha;
    }
 
    inline bool has_field_soundspeed() {
 
        // this should not be needed idealy, but we need the pressure on the ghosts and
        // we don't want to communicate it as it can be recomputed from the other fields
        // hence we copy the soundspeed at the end of the step to a field in the patchdata
        // cf eos module there is another soundspeed field available as a Compute field
        // unifying the patchdata and the ghosts is really needed ...
 
        bool is_varying_alpha
            = bool(std::get_if<VaryingMM97>(&config)) || bool(std::get_if<VaryingCD10>(&config));
        return is_varying_alpha;
    }
 
    inline void print_status() {
        logger::raw_ln("--- artificial viscosity config");
 
        if (None *v = std::get_if<None>(&config)) {
            logger::raw_ln("  Config Type : None (No artificial viscosity)");
        } else if (Constant *v = std::get_if<Constant>(&config)) {
            logger::raw_ln("  Config Type : Constant (Constant artificial viscosity)");
            logger::raw_ln("  alpha_u  =", v->alpha_u);
            logger::raw_ln("  alpha_AV =", v->alpha_AV);
            logger::raw_ln("  beta_AV  =", v->beta_AV);
        } else if (VaryingMM97 *v = std::get_if<VaryingMM97>(&config)) {
            logger::raw_ln("  Config Type : VaryingMM97 (Morris & Monaghan 1997)");
            logger::raw_ln("  alpha_min   =", v->alpha_min);
            logger::raw_ln("  alpha_max   =", v->alpha_max);
            logger::raw_ln("  sigma_decay =", v->sigma_decay);
            logger::raw_ln("  alpha_u     =", v->alpha_u);
            logger::raw_ln("  beta_AV     =", v->beta_AV);
        } else if (VaryingCD10 *v = std::get_if<VaryingCD10>(&config)) {
            logger::raw_ln("  Config Type : VaryingCD10 (Cullen & Dehnen 2010)");
            logger::raw_ln("  alpha_min   =", v->alpha_min);
            logger::raw_ln("  alpha_max   =", v->alpha_max);
            logger::raw_ln("  sigma_decay =", v->sigma_decay);
            logger::raw_ln("  alpha_u     =", v->alpha_u);
            logger::raw_ln("  beta_AV     =", v->beta_AV);
        } else if (ConstantDisc *v = std::get_if<ConstantDisc>(&config)) {
            logger::raw_ln("  Config Type : constant disc");
            logger::raw_ln("  alpha_AV   =", v->alpha_AV);
            logger::raw_ln("  alpha_u     =", v->alpha_u);
            logger::raw_ln("  beta_AV     =", v->beta_AV);
        } else {
            shambase::throw_unimplemented();
        }
 
        logger::raw_ln("--- artificial viscosity config (deduced)");
 
        logger::raw_ln("-------------");
    }
 
    inline std::optional<Tscal> get_alpha_u() {
        if (const Constant *v = std::get_if<Constant>(&config)) {
            return v->alpha_u;
        } else if (const VaryingMM97 *v = std::get_if<VaryingMM97>(&config)) {
            return v->alpha_u;
        } else if (const VaryingCD10 *v = std::get_if<VaryingCD10>(&config)) {
            return v->alpha_u;
        } else if (const ConstantDisc *v = std::get_if<ConstantDisc>(&config)) {
            return v->alpha_u;
        } else if (const None *v = std::get_if<None>(&config)) {
            return std::nullopt;
        } else {
            shambase::throw_unimplemented();
            return std::nullopt;
        }
    }
};
 
namespace shammodels::sph {
 
    template<class Tvec>
    inline void to_json(nlohmann::json &j, const AVConfig<Tvec> &p) {
        std::visit(
            [&](const auto &value) {
                j         = value;
                j["type"] = value.variant_type_name;
            },
            p.config);
    }
    template<class Tvec>
    inline void from_json(const nlohmann::json &j, AVConfig<Tvec> &p) {
        using T = AVConfig<Tvec>;
 
        using Tscal = shambase::VecComponent<Tvec>;
 
        if (!j.contains("type") && !j.contains("av_type")) {
            throw shambase::make_except_with_loc<std::runtime_error>(
                "neither \"type\" nor \"av_type\" in this json, can not infer type json=\n"
                + j.dump(4));
        }
 
        std::string av_type;
        if (j.contains("type")) {
            j.at("type").get_to(av_type);
        } else {
            j.at("av_type").get_to(av_type);
        }
 
        shamrock::json_deserialize_variant(j, av_type, p.config);
    }
 
} // namespace shammodels::sph