api.hpp

#ifndef __BIOMC_API_HPP__
#define __BIOMC_API_HPP__
 
#include "common/logger.hpp"
#include <api/results.hpp>
#include <common/execinfo.hpp>
#include <core/case_data.hpp>
#include <core/scalar_factory.hpp>
#include <core/simulation_parameters.hpp>
#include <cstdlib>
#include <memory>
#include <optional>
#include <simulation/feed_descriptor.hpp>
#include <simulation/mass_transfer.hpp>
#include <span>
#include <string_view>
#include <utility>

namespace Api
{
  constexpr std::array<int, 3>
  get_version()
  {
    return { _BIOMC_VERSION_MAJOR, _BIOMC_VERSION_MINOR, _BIOMC_VERSION_DEV };
  }
 
  void finalise();

  struct SimulationInstance
  {
  public:
    SimulationInstance(const SimulationInstance&) = delete;
    SimulationInstance(SimulationInstance&&) = default;
    SimulationInstance& operator=(const SimulationInstance&) = delete;
    SimulationInstance& operator=(SimulationInstance&&) = default;

    static std::optional<std::unique_ptr<SimulationInstance> >
    init(int argc,
         char** argv,
         std::optional<std::size_t> run_id = std::nullopt) noexcept;

    SimulationInstance() = delete;
    ~SimulationInstance();

    ApiResult apply(bool to_load) noexcept;

    ApiResult apply() noexcept;

    ApiResult apply_load() noexcept;

    ApiResult
    register_parameters(Core::UserControlParameters&& params) noexcept;

    bool register_result_path(std::string_view path);
 
    ApiResult
    register_initial_condition(Core::ScalarFactory::ScalarVariant&& type);
    ApiResult register_initialiser_file_path(std::string_view path);
    ApiResult register_cma_path(std::string_view path);

    bool register_serde(std::string_view path);

    ApiResult register_model_name(std::string_view path);
 
    ApiResult set_feed(Simulation::Feed::FeedDescriptor feed_variant,
                       Phase phase = Phase::Liquid);
 
    ApiResult set_feed_constant(double _flow,
                                double _concentration,
                                std::size_t _species,
                                std::size_t _position,
                                bool gas = false,
                                bool fed_batch = false);
 
    ApiResult set_feed_constant_different_output(double _flow,
                                                 double _concentration,
                                                 std::size_t _species,
                                                 std::size_t input_position,
                                                 std::size_t output_position,
                                                 bool gas = false);
 
    ApiResult set_mtr(Simulation::MassTransfer::Type::MtrTypeVariant&& variant);
 
    void set_auto_mtr();
 
    // /**
    //  * @brief Configure feed constants for the simulation.
    //  *
    //  * @param _flow A constant flow value.
    //  * @param concentrations A span of concentrations values.
    //  * @param _position A span of position indices.
    //  * @param _species A span of species indices.
    //  * @param gas Flag indicating whether the feed is gas-phase.
    //  * @return True if the feed was successfully configured; false otherwise.
    //  */
    // [[deprecated]]bool set_feed_constant(double _flow,
    //                        std::span<double> _concentration,
    //                        std::span<std::size_t> _position,
    //                        std::span<std::size_t> _species,
    //                        bool gas = false,
    //                        bool fed_batch = false);
 
    // [[deprecated]]bool set_feed_constant_from_position(double _flow,
    //                                      std::span<double> _concentration,
    //                                      std::span<std::size_t> _position,
    //                                      std::span<std::size_t> _species,
    //                                      std::optional<std::vector<std::size_t>>
    //                                      _output_position, bool gas = false,
    //                                      bool fed_batch = false);
 
    // [[deprecated]]bool set_feed_constant_from_rvalue(double _f,
    //                                    std::vector<double>&& _target,
    //                                    std::vector<std::size_t>&& _position,
    //                                    std::vector<std::size_t>&& _species,
    //                                    bool gas = false,
    //                                    bool fed_batch = false);
 
    ApiResult
    register_scalar_initiazer(Core::ScalarFactory::ScalarVariant&& var);

    [[nodiscard]] int get_id() const;
 
    [[nodiscard]] const ExecInfo& get_exec_info() const;

    ApiResult exec() noexcept;
 
    void
    set_logger(std::shared_ptr<IO::Logger> _logger)
    {
 
      logger = std::move(_logger);
    }
 
    [[nodiscard]] auto&
    get_logger() const
    {
      return logger;
    }
 
  private:
    int id{}; 

    SimulationInstance(int argc,
                       char** argv,
                       std::optional<std::size_t> run_id);
 
    std::shared_ptr<IO::Logger> logger;
 
    std::optional<Core::ScalarFactory::ScalarVariant> scalar_initializer_variant
        = std::nullopt;
    Core::CaseData _data;               
    Core::UserControlParameters params; 
    bool loaded = false;  
    bool applied = false; 
    bool registered = false; 
    std::optional<Simulation::Feed::SimulationFeed> feed
        = std::nullopt; 
    std::optional<Simulation::MassTransfer::Type::MtrTypeVariant> mtr_type
        = std::nullopt;
 
    bool auto_mtr;
  };
 
} // namespace Api
#endif