simulation.hpp

Go to the documentation of this file.

#pragma once

 
#include <memory>
 
#include "orrery/backend/executor.hpp"
#include "orrery/core/diagnostics.hpp"
#include "orrery/core/particle_data.hpp"
#include "orrery/core/types.hpp"
#include "orrery/integrators/integrator.hpp"
#include "orrery/solvers/force_solver.hpp"
 
namespace orrery::sim {
 
class RunOutput;

class Simulation {
public:
    Simulation(core::ParticleData particles, std::unique_ptr<solvers::ForceSolver> solver,
               std::unique_ptr<integrators::Integrator> integrator, core::Real timestep,
               std::unique_ptr<backend::Executor> executor = nullptr,
               std::unique_ptr<RunOutput> output = nullptr);
 
    ~Simulation();
 
    Simulation(const Simulation&) = delete;
    Simulation& operator=(const Simulation&) = delete;
    Simulation(Simulation&&) noexcept;
    Simulation& operator=(Simulation&&) noexcept;

    void step();

    void run(core::Index steps);

    void restore(core::ParticleData particles, core::Index step,
                 bool accelerations_are_current = false);
 
    [[nodiscard]] core::Index step_index() const noexcept { return step_; }

    [[nodiscard]] core::Real time() const noexcept {
        return static_cast<core::Real>(step_) * timestep_;
    }
 
    [[nodiscard]] core::Real timestep() const noexcept { return timestep_; }
 
    [[nodiscard]] const core::ParticleData& particles() const noexcept { return particles_; }
 
    [[nodiscard]] const solvers::ForceSolver& solver() const noexcept { return *solver_; }
 
    [[nodiscard]] const integrators::Integrator& integrator() const noexcept {
        return *integrator_;
    }

    [[nodiscard]] core::Diagnostics measure() const;
 
private:
    std::unique_ptr<backend::Executor> executor_;
 
    std::unique_ptr<solvers::ForceSolver> solver_;
    std::unique_ptr<integrators::Integrator> integrator_;
    std::unique_ptr<RunOutput> output_;
 
    core::ParticleData particles_;
    core::Real timestep_;
    core::Index step_ = 0;
};
 
} // namespace orrery::sim