SymbolicSimulatorCore.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/Component.hpp>
#include <icarus/core/ComponentConfig.hpp>
#include <icarus/core/ComponentFactory.hpp>
#include <icarus/core/CoreTypes.hpp>
#include <icarus/core/Error.hpp>
#include <icarus/signal/Backplane.hpp>
#include <icarus/signal/Registry.hpp>
#include <icarus/signal/SignalRouter.hpp>
#include <icarus/sim/SimulatorConfig.hpp>
#include <icarus/sim/StateManager.hpp>
 
#include <janus/core/JanusTypes.hpp>
 
#include <algorithm>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace icarus::staging {

class SymbolicSimulatorCore {
  public:
    using Scalar = janus::SymbolicScalar;

    explicit SymbolicSimulatorCore(const SimulatorConfig &config)
        : config_(config), backplane_(registry_) {
        CreateComponents();
        ProvisionComponents();
        ApplyRouting();
        AllocateState();
        StageComponents();
    }
 
    // =========================================================================
    // State Access
    // =========================================================================

    void SetState(const JanusVector<Scalar> &x) {
        if (x.size() != state_manager_.GetState().size()) {
            throw std::invalid_argument("SymbolicSimulatorCore::SetState: size mismatch");
        }
        state_manager_.SetState(x);
    }

    void SetTime(Scalar t) { time_ = t; }

    JanusVector<Scalar> ComputeDerivatives() {
        state_manager_.ZeroDerivatives();
 
        Scalar dt = Scalar(config_.dt);
 
        // Build execution order based on scheduler priority
        // Components with lower priority values run first
        std::vector<Component<Scalar> *> exec_order;
        exec_order.reserve(components_.size());
 
        // Build component priority map from scheduler config
        std::unordered_map<std::string, int> priority_map;
        for (const auto &group : config_.scheduler.groups) {
            for (const auto &member : group.members) {
                priority_map[member.component] = group.priority;
            }
        }
 
        // Copy component pointers and sort by priority
        for (auto &comp : components_) {
            exec_order.push_back(comp.get());
        }
        std::stable_sort(
            exec_order.begin(), exec_order.end(),
            [&priority_map](Component<Scalar> *a, Component<Scalar> *b) {
                int pa = priority_map.count(a->FullName()) ? priority_map[a->FullName()]
                                                           : 1000; // Default high priority
                int pb = priority_map.count(b->FullName()) ? priority_map[b->FullName()] : 1000;
                return pa < pb;
            });
 
        // Execute in priority order
        for (auto *comp : exec_order) {
            comp->PreStep(time_, dt);
        }
        for (auto *comp : exec_order) {
            comp->Step(time_, dt);
        }
        for (auto *comp : exec_order) {
            comp->PostStep(time_, dt);
        }
 
        return state_manager_.GetDerivatives();
    }

    [[nodiscard]] std::size_t GetStateSize() const { return state_manager_.TotalSize(); }

    [[nodiscard]] JanusVector<Scalar> GetState() const { return state_manager_.GetState(); }

    [[nodiscard]] JanusVector<Scalar> GetDerivatives() const {
        return state_manager_.GetDerivatives();
    }
 
    // =========================================================================
    // Signal Access
    // =========================================================================

    [[nodiscard]] Scalar GetSignal(const std::string &name) const {
        return registry_.GetByName(name);
    }

    void SetSignal(const std::string &name, Scalar value) { registry_.SetByName(name, value); }

    [[nodiscard]] bool HasSignal(const std::string &name) const {
        return registry_.HasSignal(name);
    }

    [[nodiscard]] std::vector<std::string> GetSignalNames() const {
        return registry_.get_all_signal_names();
    }

    [[nodiscard]] const std::vector<StateBinding<Scalar>> &GetStateBindings() const {
        return state_manager_.GetBindings();
    }

    [[nodiscard]] Component<Scalar> *GetComponent(const std::string &name) const {
        for (const auto &comp : components_) {
            if (comp->FullName() == name) {
                return comp.get();
            }
        }
        return nullptr;
    }

    [[nodiscard]] std::size_t NumComponents() const { return components_.size(); }
 
  private:
    // =========================================================================
    // Private Methods
    // =========================================================================
 
    void CreateComponents() {
        auto &factory = ComponentFactory<Scalar>::Instance();
 
        for (const auto &comp_cfg : config_.components) {
            if (!factory.HasType(comp_cfg.type)) {
                throw ConfigError("SymbolicSimulatorCore: No symbolic registration for component "
                                  "type '" +
                                  comp_cfg.type +
                                  "'. "
                                  "Ensure component uses ICARUS_REGISTER_COMPONENT macro.");
            }
            auto component = factory.Create(comp_cfg);
            components_.push_back(std::move(component));
        }
    }
 
    void ProvisionComponents() {
        for (auto &comp : components_) {
            backplane_.set_context(comp->Entity(), comp->Name());
            backplane_.clear_tracking();
            comp->Provision(backplane_);
            // Component marks itself as provisioned internally
            backplane_.clear_context();
        }
    }
 
    void ApplyRouting() {
        for (const auto &route : config_.routes) {
            router_.AddRoute(route);
        }
        router_.ApplyRoutes(backplane_);
    }
 
    void AllocateState() {
        // Phase 6: Discover states from registry instead of scanning components
        state_manager_.DiscoverStates(registry_);
    }
 
    void StageComponents() {
        for (auto &comp : components_) {
            backplane_.set_context(comp->Entity(), comp->Name());
            backplane_.clear_tracking();
            comp->Stage(backplane_);
            // Component marks itself as staged internally
            backplane_.clear_context();
        }
    }
 
    // =========================================================================
    // Private Data
    // =========================================================================
 
    SimulatorConfig config_;
 
    // Components
    std::vector<std::unique_ptr<Component<Scalar>>> components_;
 
    // Signal system
    SignalRegistry<Scalar> registry_;
    Backplane<Scalar> backplane_;
    signal::SignalRouter<Scalar> router_;
 
    // State management
    StateManager<Scalar> state_manager_;
 
    // Time
    Scalar time_{0.0};
};
 
} // namespace icarus::staging