model.hpp

 
// File: model.hpp                                                            //
// Project: respond                                                           //
// Created Date: 2026-02-05                                                   //
// Author: Matthew Carroll                                                    //
// -----                                                                      //
// Last Modified: 2026-09-24                                                  //
// Modified By: Matthew Carroll                                               //
// -----                                                                      //
// Copyright (c) 2026 Syndemics Lab at Boston Medical Center                  //
#ifndef RESPOND_MODEL_HPP_
#define RESPOND_MODEL_HPP_
 
#include <memory>
#include <string>
#include <vector>
 
#include <Eigen/Dense>
 
#include <respond/constants.hpp>
#include <respond/history.hpp>
#include <respond/runtime_config.hpp>
#include <respond/timestep.hpp>
 
namespace respond {
class Model {
public:
    //
    // Rule of Five: Copy and Move Semantics
    //
 
    [[deprecated("Use Model::Create(name, RuntimeConfig) instead")]]
    static std::unique_ptr<Model>
    Create(const std::string &name,
           const std::string &log_name = RESPOND_DEFAULT_LOG,
           const std::string &log_filepath = RESPOND_DEFAULT_LOG_FILE);
 
    [[deprecated("Use Model::Create(name, RuntimeConfig) instead")]]
    static std::unique_ptr<Model>
    Create(const std::string &name, const unsigned int processor_count,
           const std::string &log_name = RESPOND_DEFAULT_LOG,
           const std::string &log_filepath = RESPOND_DEFAULT_LOG_FILE);
 
    [[deprecated("Use Model::Create(name, RuntimeConfig) instead")]]
    static std::unique_ptr<Model>
    Create(const std::string &name, const ExecutionConfig &execution_config,
           const std::string &log_name = RESPOND_DEFAULT_LOG,
           const std::string &log_filepath = RESPOND_DEFAULT_LOG_FILE);
 
    static std::unique_ptr<Model> Create(const std::string &name,
                                         const RuntimeConfig &runtime_config);
 
    virtual ~Model() = default;
 
    Model(const Model &) = delete;
    Model &operator=(const Model &) = delete;
 
    virtual std::unique_ptr<Model> clone() const = 0;
 
    //
    // Model Behavior Methods: Timestep Execution and History Management
    //
 
    virtual void AddTimestep(const Timestep &timestep) = 0;
 
    virtual void RunTimestep() = 0;
 
    virtual void RunTimestep(size_t idx) = 0;
 
    virtual void RunTimesteps() = 0;
 
    virtual void ClearTimesteps() = 0;
 
    virtual void ClearHistories() = 0;
 
    virtual void CreateDefaultHistories() = 0;
 
    //
    // Getters and Setters for Model State and Metadata
    //
 
    virtual Timestep GetTimestepAtIndex(size_t index) const = 0;
 
    virtual const Eigen::Ref<const Eigen::VectorXd> GetState() const = 0;
 
    virtual std::string GetName() const = 0;
 
    virtual const std::map<std::string, History> &GetHistories() const = 0;
 
    virtual int GetTimestep() const = 0;
 
    virtual int GetHistoryCaptureInterval() const = 0;
 
    virtual int GetFinalTimestep() const = 0;
 
    virtual bool GetInitialHistoryRecorded() const = 0;
 
    virtual void SetState(const Eigen::Ref<const Eigen::VectorXd> &state) = 0;
 
    virtual void SetHistoryCaptureInterval(int interval) = 0;
 
    virtual void SetFinalTimestep(int final_timestep) = 0;
 
    virtual void SetInitialHistoryRecorded(bool recorded) = 0;
 
    virtual void Serialize(std::ostream &os) const = 0;
 
protected:
    Model() = default;
};
 
inline std::ostream &operator<<(std::ostream &os, const Model &model) {
    model.Serialize(os);
    return os;
}
 
} // namespace respond
 
#endif // RESPOND_MODEL_HPP_