simulation.hpp

 
// File: simulation.hpp                                                       //
// Project: respond                                                           //
// Created Date: 2026-02-05                                                   //
// Author: Matthew Carroll                                                    //
// -----                                                                      //
// Last Modified: 2026-07-22                                                  //
// Modified By: Matthew Carroll                                               //
// -----                                                                      //
// Copyright (c) 2026 Syndemics Lab at Boston Medical Center                  //
#ifndef RESPOND_SIMULATION_HPP_
#define RESPOND_SIMULATION_HPP_
 
#include <respond/constants.hpp>
#include <respond/history.hpp>
#include <respond/logging.hpp>
#include <respond/model.hpp>
 
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include <Eigen/Dense>
 
namespace respond {
class Simulation {
public:
    class ModelSlotProxy {
    public:
        ModelSlotProxy(Simulation &owner, size_t idx)
            : _owner(&owner), _idx(idx) {}
 
        Model *operator->() { return &_owner->GetModelRefOrThrow(_idx); }
 
        Model &operator*() { return _owner->GetModelRefOrThrow(_idx); }
 
        operator Model &() { return _owner->GetModelRefOrThrow(_idx); }
 
        ModelSlotProxy &operator=(const ModelSlotProxy &other) {
            return *this = static_cast<const Model &>(
                       other._owner->GetModelRefOrThrow(other._idx));
        }
 
        ModelSlotProxy &operator=(const Model &model) {
            _owner->GetModelRefOrThrow(_idx);
            _owner->_models[_idx] = model.clone();
            return *this;
        }
 
        ModelSlotProxy &operator=(const std::unique_ptr<Model> &model) {
            if (!model) {
                LogError(_owner->_log_name,
                         "Cannot assign null model pointer to simulation "
                         "slot.");
                throw std::invalid_argument(
                    "Error attempting to assign null model pointer.");
            }
            _owner->GetModelRefOrThrow(_idx);
            _owner->_models[_idx] = model->clone();
            return *this;
        }
 
    private:
        Simulation *_owner;
        size_t _idx;
    };
 
    //
    // Rule of Five: Copy and Move Semantics
    //
 
    Simulation() : Simulation(RESPOND_DEFAULT_LOG) {}
 
    Simulation(const std::string &log_name)
        : Simulation(log_name, RESPOND_DEFAULT_LOG_FILE) {}
 
    Simulation(const std::string &log_name, const std::string &log_filepath)
        : _log_name(log_name) {
        CreateFileLogger(log_name, log_filepath);
    }
 
    ~Simulation() = default;
 
    Simulation(const Simulation &other) {
        _log_name = other._log_name;
        for (const auto &m : other._models) {
            _models.push_back(m->clone());
        }
        _duration = other._duration;
        _parameter_change_times = other._parameter_change_times;
        _stratify_entering_cohort = other._stratify_entering_cohort;
        _build_summary_stats = other._build_summary_stats;
        _save_state_history = other._save_state_history;
        _timesteps_to_report = other._timesteps_to_report;
        _pivot_long = other._pivot_long;
    }
 
    Simulation &operator=(const Simulation &other) {
        if (this != &other) {
            _log_name = other._log_name;
            _models.clear();
            for (const auto &m : other._models) {
                _models.push_back(m->clone());
            }
            _duration = other._duration;
            _parameter_change_times = other._parameter_change_times;
            _stratify_entering_cohort = other._stratify_entering_cohort;
            _build_summary_stats = other._build_summary_stats;
            _save_state_history = other._save_state_history;
            _timesteps_to_report = other._timesteps_to_report;
            _pivot_long = other._pivot_long;
        }
        return *this;
    }
 
    Simulation(Simulation &&other) noexcept
        : _log_name(std::move(other._log_name)), _duration(other._duration),
          _parameter_change_times(std::move(other._parameter_change_times)),
          _stratify_entering_cohort(other._stratify_entering_cohort),
          _build_summary_stats(other._build_summary_stats),
          _save_state_history(other._save_state_history),
          _timesteps_to_report(std::move(other._timesteps_to_report)),
          _pivot_long(other._pivot_long) {
        for (const auto &m : other._models) {
            _models.push_back(m->clone());
        }
        other._models.clear();
    }
 
    Simulation &operator=(Simulation &&other) noexcept {
        if (this != &other) {
            _log_name = std::move(other._log_name);
            _duration = other._duration;
            _parameter_change_times = std::move(other._parameter_change_times);
            _stratify_entering_cohort = other._stratify_entering_cohort;
            _build_summary_stats = other._build_summary_stats;
            _save_state_history = other._save_state_history;
            _timesteps_to_report = std::move(other._timesteps_to_report);
            _pivot_long = other._pivot_long;
 
            for (const auto &m : other._models) {
                _models.push_back(m->clone());
            }
            other._models.clear();
        }
        return *this;
    }
 
    //
    // Simulation Behavior Methods: Model Management
    //
 
    std::unique_ptr<Model> CreateNewModel(const std::string &model_name) {
        _models.push_back(Model::Create(model_name, _log_name));
        return _models.back()->clone();
    }
 
    void ClearModels() { _models.clear(); }
 
    void AddModel(const std::unique_ptr<Model> &model) {
        _models.push_back(model->clone());
    }
 
    void Run(int duration = -1) {
        if (duration > 0) {
            _duration = duration;
        }
        LogInfo(_log_name, "Running simulation for duration of " +
                               std::to_string(_duration) + " timesteps.");
        for (const auto &model : _models) {
            model->SetFinalTimestep(_duration);
            model->RunTimesteps();
        }
    }
 
    //
    // Getters and Setters for Transitions and Metadata
    //
 
    std::vector<std::unique_ptr<Model>> GetModels() const {
        std::vector<std::unique_ptr<Model>> _models_copy;
        for (const auto &model : _models) {
            _models_copy.push_back(model->clone());
        }
        return _models_copy;
    }
 
    ModelSlotProxy operator[](size_t idx) {
        GetModelRefOrThrow(idx);
        return ModelSlotProxy(*this, idx);
    }
 
    const Model &operator[](size_t idx) const {
        return GetModelRefOrThrow(idx);
    }
 
    std::map<size_t, std::string> GetModelIndexNameMap() const {
        std::map<size_t, std::string> ret;
        for (size_t i = 0; i < _models.size(); ++i) {
            ret[i] = _models[i]->GetName();
        }
        return ret;
    }
 
    std::unique_ptr<Model> GetModel(int idx) const {
        if (_models.empty()) {
            LogError(_log_name, "No models available in GetModel.");
            throw std::out_of_range("Error attempting to GetModel: no models.");
        }
        if (idx < -1 || idx >= static_cast<int>(_models.size())) {
            LogError(_log_name,
                     "Index out of range in GetModel: " + std::to_string(idx));
            throw std::out_of_range("Error attempting to GetModel by index.");
        }
        // Return the last model if idx is -1
        if (idx == -1) {
            return _models.back()->clone();
        }
        return _models[idx]->clone();
    }
 
    std::vector<std::string> GetModelNames() const {
        std::vector<std::string> ret;
        for (auto &m : _models) {
            ret.push_back(m->GetName());
        }
        return ret;
    }
 
    const std::map<std::string, History> &GetModelHistory(size_t idx) const {
        if (idx >= _models.size()) {
            LogError(_log_name, "Index out of range in GetModelHistory: " +
                                    std::to_string(idx));
            throw std::out_of_range(
                "Error attempting to GetModelHistory by index.");
        }
        return _models[idx]->GetHistories();
    }
 
    const std::vector<std::string> GetModelHistoryNames(size_t idx) const {
        if (idx >= _models.size()) {
            LogError(_log_name, "Index out of range in GetModelHistoryNames: " +
                                    std::to_string(idx));
            throw std::out_of_range(
                "Error attempting to GetModelHistoryNames by index.");
        }
        std::vector<std::string> ret;
        for (const auto &kv : _models[idx]->GetHistories()) {
            ret.push_back(kv.first);
        }
        return ret;
    }
 
    void SetDuration(int duration) { _duration = duration; }
 
private:
    Model &GetModelRefOrThrow(size_t idx) {
        if (idx >= _models.size()) {
            LogError(_log_name, "Index out of range in model access: " +
                                    std::to_string(idx));
            throw std::out_of_range("Error attempting to access model by "
                                    "index.");
        }
        return *_models[idx];
    }
 
    const Model &GetModelRefOrThrow(size_t idx) const {
        if (idx >= _models.size()) {
            LogError(_log_name, "Index out of range in model access: " +
                                    std::to_string(idx));
            throw std::out_of_range("Error attempting to access model by "
                                    "index.");
        }
        return *_models[idx];
    }
 
    std::string _log_name;
    std::vector<std::unique_ptr<Model>> _models;
 
    int _duration = 1; // Default simulation duration in timesteps
    std::vector<int> _parameter_change_times;
    bool _stratify_entering_cohort;
 
    bool _build_summary_stats;
    bool _save_state_history;
    std::vector<int> _timesteps_to_report;
    bool _pivot_long;
};
} // namespace respond
 
#endif // RESPOND_SIMULATION_HPP_