configuration.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include "orrery/core/types.hpp"
 
namespace orrery::sim {

enum class SolverKind : std::uint8_t {
    kDirect,
    kBarnesHut,
    kSyclDirect,
    kSyclTree,
};

enum class IntegratorKind : std::uint8_t {
    kVelocityVerlet,
    kYoshida4,
    kRungeKutta4,
};

enum class InitialConditionKind : std::uint8_t {
    kPlummer,
    kUniformSphere,
    kKepler,
    kDiscGalaxy,
    kGalaxyCollision,
};

enum class ExecutorKind : std::uint8_t {
    kSerial,
    kStatic,
    kWorkStealing,
};

[[nodiscard]] std::string_view to_string(SolverKind kind) noexcept;
[[nodiscard]] std::string_view to_string(IntegratorKind kind) noexcept;
[[nodiscard]] std::string_view to_string(InitialConditionKind kind) noexcept;
[[nodiscard]] std::string_view to_string(ExecutorKind kind) noexcept;

[[nodiscard]] std::optional<SolverKind> parse_solver_kind(std::string_view text) noexcept;
[[nodiscard]] std::optional<IntegratorKind> parse_integrator_kind(std::string_view text) noexcept;
[[nodiscard]] std::optional<InitialConditionKind>
parse_initial_condition_kind(std::string_view text) noexcept;
[[nodiscard]] std::optional<ExecutorKind> parse_executor_kind(std::string_view text) noexcept;

[[nodiscard]] std::string solver_kind_names();
[[nodiscard]] std::string integrator_kind_names();
[[nodiscard]] std::string initial_condition_kind_names();
[[nodiscard]] std::string executor_kind_names();

struct RunSettings {
    core::Real timestep = 0;

    core::Index steps = 0;

    std::uint64_t seed = 0;
 
    [[nodiscard]] friend bool operator==(const RunSettings&, const RunSettings&) = default;
};

struct InitialConditionSettings {
    InitialConditionKind kind = InitialConditionKind::kPlummer;

    core::Index count = 0;

    core::Real total_mass = 1;

    core::Real scale_radius = 0;

    core::Real radius = 1;

    core::Real mass_fraction_cutoff = static_cast<core::Real>(0.999);

    core::Real primary_mass = 1;
    core::Real secondary_mass = 1;
 
    core::Real semi_major_axis = 1;
    core::Real eccentricity = 0;

    core::Real bulge_fraction = static_cast<core::Real>(0.2);

    core::Real scale_length = 1;
 
    core::Real scale_height = static_cast<core::Real>(0.1);

    core::Real bulge_radius = static_cast<core::Real>(0.2);

    core::Real inclination = 0;
    core::Real position_angle = 0;

    core::Real mass_ratio = static_cast<core::Real>(0.5);

    core::Real secondary_inclination = 1;
    core::Real secondary_position_angle = 0;

    core::Real separation = 20;
    core::Real impact_parameter = 2;

    core::Real approach_speed = static_cast<core::Real>(0.8);
 
    [[nodiscard]] friend bool operator==(const InitialConditionSettings&,
                                         const InitialConditionSettings&) = default;
};

struct SolverSettings {
    SolverKind kind = SolverKind::kBarnesHut;

    core::Real softening = 0;

    core::Real opening_angle = static_cast<core::Real>(0.5);
 
    core::Index leaf_capacity = 32;
 
    bool quadrupole = false;
 
    ExecutorKind executor = ExecutorKind::kWorkStealing;

    unsigned threads = 0;

    bool allow_cpu_fallback = true;
 
    [[nodiscard]] friend bool operator==(const SolverSettings&, const SolverSettings&) = default;
};
 
struct IntegratorSettings {
    IntegratorKind kind = IntegratorKind::kVelocityVerlet;
 
    [[nodiscard]] friend bool operator==(const IntegratorSettings&,
                                         const IntegratorSettings&) = default;
};

struct OutputSettings {
    std::string trajectory_path;
 
    core::Index trajectory_stride = 0;

    bool trajectory_velocities = false;

    std::string diagnostics_path;

    core::Index diagnostics_stride = 0;

    std::string checkpoint_path;
 
    core::Index checkpoint_stride = 0;
 
    [[nodiscard]] friend bool operator==(const OutputSettings&, const OutputSettings&) = default;
};

struct Configuration {
    RunSettings run;
    InitialConditionSettings initial_conditions;
    SolverSettings solver;
    IntegratorSettings integrator;
    OutputSettings output;
 
    [[nodiscard]] friend bool operator==(const Configuration&, const Configuration&) = default;
};

[[nodiscard]] std::vector<std::string> problems_with(const Configuration& configuration);

[[nodiscard]] core::Real resolved_scale_radius(const InitialConditionSettings& settings) noexcept;
 
} // namespace orrery::sim