direct_solver.hpp

Go to the documentation of this file.

#pragma once

 
#include <span>
#include <string_view>
 
#include "orrery/backend/executor.hpp"
#include "orrery/core/softening.hpp"
#include "orrery/core/types.hpp"
#include "orrery/core/vec3_span.hpp"
#include "orrery/solvers/direct_kernel.hpp"
#include "orrery/solvers/force_solver.hpp"
#include "orrery/solvers/interaction_count.hpp"
 
namespace orrery::solvers {

class DirectSolver final : public ForceSolver {
public:
    DirectSolver() = default;

    explicit DirectSolver(core::Softening softening) noexcept : softening_(softening) {}

    explicit DirectSolver(backend::Executor& executor) noexcept : executor_(&executor) {}

    DirectSolver(core::Softening softening, backend::Executor& executor) noexcept
        : softening_(softening), executor_(&executor) {}

    void evaluate(core::Vec3Span<const core::Real> positions, std::span<const core::Real> masses,
                  core::Vec3Span<core::Real> accelerations) override;
 
    [[nodiscard]] std::string_view name() const noexcept override { return "direct"; }
 
    [[nodiscard]] core::Softening softening() const noexcept override { return softening_; }
 
    [[nodiscard]] InteractionCount interaction_count() const noexcept override { return count_; }
 
    void reset_interaction_count() noexcept override { count_ = {}; }

    [[nodiscard]] const backend::Executor* executor() const noexcept { return executor_; }

    void select_kernel(KernelKind kind) noexcept {
        kernel_ = kernel_available(kind) ? kind : KernelKind::kScalar;
    }

    [[nodiscard]] KernelKind kernel() const noexcept { return kernel_; }
 
private:
    core::Softening softening_;

    backend::Executor* executor_{nullptr};

    KernelKind kernel_{fastest_available_kernel()};
 
    InteractionCount count_;
};
 
} // namespace orrery::solvers