IntegrationManager.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/CoreTypes.hpp>
#include <icarus/sim/integrators/Integrator.hpp>
#include <icarus/sim/integrators/IntegratorFactory.hpp>
#include <icarus/sim/integrators/IntegratorTypes.hpp>
 
#include <functional>
#include <memory>
#include <stdexcept>
 
namespace icarus {
 
// =============================================================================
// IntegrationManager
// =============================================================================

template <typename Scalar> class IntegrationManager {
  public:
    using DerivativeFunc = std::function<JanusVector<Scalar>(Scalar, const JanusVector<Scalar> &)>;
 
    IntegrationManager() = default;

    void Configure(const IntegratorConfig<Scalar> &config) {
        config_ = config;
        integrator_ = IntegratorFactory<Scalar>::Create(config);
    }

    void Configure(IntegratorType type) {
        config_ = IntegratorConfig<Scalar>::ForMethod(type);
        integrator_ = IntegratorFactory<Scalar>::Create(config_);
    }

    void Configure(const std::string &type_name) {
        IntegratorType type = parse_integrator_type(type_name);
        Configure(type);
    }

    void ConfigureDefault() {
        config_ = IntegratorConfig<Scalar>::RK4Default();
        integrator_ = IntegratorFactory<Scalar>::Create(config_);
    }

    [[nodiscard]] JanusVector<Scalar> Step(const DerivativeFunc &deriv_func,
                                           const JanusVector<Scalar> &X, Scalar t, Scalar dt) {
        if (!integrator_) {
            throw std::runtime_error(
                "IntegrationManager: integrator not configured. Call Configure() first.");
        }
        return integrator_->Step(deriv_func, X, t, dt);
    }

    [[nodiscard]] AdaptiveStepResult<Scalar> AdaptiveStep(const DerivativeFunc &deriv_func,
                                                          const JanusVector<Scalar> &X, Scalar t,
                                                          Scalar dt_request) {
        if (!integrator_) {
            throw std::runtime_error(
                "IntegrationManager: integrator not configured. Call Configure() first.");
        }
        if (!integrator_->IsAdaptive()) {
            throw std::runtime_error(
                "IntegrationManager: AdaptiveStep() requires an adaptive integrator. "
                "Current integrator: " +
                integrator_->Name());
        }
 
        auto *adaptive = dynamic_cast<AdaptiveIntegrator<Scalar> *>(integrator_.get());
        if (!adaptive) {
            throw std::runtime_error("IntegrationManager: failed to cast to AdaptiveIntegrator");
        }
        return adaptive->AdaptiveStep(deriv_func, X, t, dt_request);
    }

    [[nodiscard]] IntegratorType Type() const {
        if (integrator_) {
            return integrator_->Type();
        }
        return config_.type;
    }

    [[nodiscard]] const IntegratorConfig<Scalar> &Config() const { return config_; }

    [[nodiscard]] std::string Name() const {
        if (integrator_) {
            return integrator_->Name();
        }
        return to_string(config_.type);
    }

    [[nodiscard]] bool IsConfigured() const { return integrator_ != nullptr; }

    [[nodiscard]] bool IsAdaptive() const { return integrator_ && integrator_->IsAdaptive(); }

    [[nodiscard]] Integrator<Scalar> *GetIntegrator() { return integrator_.get(); }

    [[nodiscard]] const Integrator<Scalar> *GetIntegrator() const { return integrator_.get(); }
 
  private:
    std::unique_ptr<Integrator<Scalar>> integrator_;
    IntegratorConfig<Scalar> config_;
};
 
} // namespace icarus