EOSConfig.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 "shambase/exception.hpp"
#include "shambase/type_traits.hpp"
#include "nlohmann/json_fwd.hpp"
#include "shambackends/vec.hpp"
#include "shamphys/eos_config.hpp"
#include "shamsys/legacy/log.hpp"
#include <nlohmann/json.hpp>
#include <type_traits>
#include <stdexcept>
#include <string>
#include <variant>
 
namespace shammodels {
 
    template<class Tvec>
    struct EOSConfig {
        using Tscal = shambase::VecComponent<Tvec>;
 
        static constexpr u32 dim = shambase::VectorProperties<Tvec>::dimension;
 
        // EOS types definition usable in the code
 
        using Adiabatic = shamphys::EOS_Config_Adiabatic<Tscal>;
 
        using Polytropic = shamphys::EOS_Config_Polytropic<Tscal>;
 
        using Isothermal = shamphys::EOS_Config_Isothermal<Tscal>;
 
        struct LocallyIsothermal {};
 
        using LocallyIsothermalLP07 = shamphys::EOS_Config_LocallyIsothermal_LP07<Tscal>;
 
        using LocallyIsothermalFA2014
            = shamphys::EOS_Config_LocallyIsothermalDisc_Farris2014<Tscal>;
 
        using LocallyIsothermalFA2014Extended
            = shamphys::EOS_Config_LocallyIsothermalDisc_ExtendedFarris2014<Tscal>;
 
        using Fermi = shamphys::EOS_Config_Fermi<Tscal>;
 
        using Variant = std::variant<
            Isothermal,
            Adiabatic,
            Polytropic,
            LocallyIsothermal,
            LocallyIsothermalLP07,
            LocallyIsothermalFA2014,
            LocallyIsothermalFA2014Extended,
            Fermi>;
 
        Variant config = Adiabatic{};
 
        inline void set_isothermal(Tscal cs) { config = Isothermal{cs}; }
 
        inline void set_adiabatic(Tscal gamma) { config = Adiabatic{gamma}; }
 
        inline void set_polytropic(Tscal K, Tscal gamma) { config = Polytropic{K, gamma}; }
 
        inline void set_locally_isothermal() { config = LocallyIsothermal{}; }
 
        inline void set_locally_isothermalLP07(Tscal cs0, Tscal q, Tscal r0) {
            config = LocallyIsothermalLP07{cs0, q, r0};
        }
 
        inline void set_locally_isothermalFA2014(Tscal h_over_r) {
            config = LocallyIsothermalFA2014{h_over_r};
        }
 
        inline void set_locally_isothermalFA2014_extended(
            Tscal cs0, Tscal q, Tscal r0, u32 n_sinks) {
            config = LocallyIsothermalFA2014Extended{cs0, q, r0, n_sinks};
        }
 
        inline void set_fermi(Tscal mu_e) { config = Fermi{mu_e}; }
 
        inline void print_status();
    };
 
} // namespace shammodels
 
template<class Tvec>
void shammodels::EOSConfig<Tvec>::print_status() {
 
    std::string s;
    if constexpr (std::is_same_v<f32_3, Tvec>) {
        s = "f32_3";
    }
 
    if constexpr (std::is_same_v<f64_3, Tvec>) {
        s = "f64_3";
    }
 
    logger::raw_ln("EOS config", s, ":");
    if (Isothermal *eos_config = std::get_if<Isothermal>(&config)) {
        logger::raw_ln("isothermal : ");
        logger::raw_ln("cs", eos_config->cs);
    } else if (Adiabatic *eos_config = std::get_if<Adiabatic>(&config)) {
        logger::raw_ln("adiabatic : ");
        logger::raw_ln("gamma", eos_config->gamma);
    } else if (Polytropic *eos_config = std::get_if<Polytropic>(&config)) {
        logger::raw_ln("polytropic : ");
        logger::raw_ln("K", eos_config->K);
        logger::raw_ln("gamma", eos_config->gamma);
    } else if (LocallyIsothermal *eos_config = std::get_if<LocallyIsothermal>(&config)) {
        logger::raw_ln("locally isothermal : ");
    } else if (LocallyIsothermalLP07 *eos_config = std::get_if<LocallyIsothermalLP07>(&config)) {
        logger::raw_ln("locally isothermal (Lodato Price 2007) : ");
    } else if (
        LocallyIsothermalFA2014 *eos_config = std::get_if<LocallyIsothermalFA2014>(&config)) {
        logger::raw_ln("locally isothermal (Farris 2014) : ");
    } else if (
        LocallyIsothermalFA2014Extended *eos_config
        = std::get_if<LocallyIsothermalFA2014Extended>(&config)) {
        logger::raw_ln("locally isothermal (Farris 2014 extended) : ");
    } else if (Fermi *eos_config = std::get_if<Fermi>(&config)) {
        logger::raw_ln("Fermi : ");
        logger::raw_ln("mu_e", eos_config->mu_e);
    } else {
        shambase::throw_unimplemented();
    }
}
 
namespace shammodels {
 
    template<class Tvec>
    void to_json(nlohmann::json &j, const EOSConfig<Tvec> &p);
 
    template<class Tvec>
    void from_json(const nlohmann::json &j, EOSConfig<Tvec> &p);
 
} // namespace shammodels