feed_descriptor.hpp

#ifndef __SIMULATION_FEED_DESCRIPTOR_HPP__
#define __SIMULATION_FEED_DESCRIPTOR_HPP__
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <ranges>
#include <variant>
#include <vector>
 
enum class Phase
{
  Liquid,
  Gas
};
 
enum class FeedType : std::uint8_t
{
  Constant,
  Exponential,
  Linear,
  // DelayedConstant,
  // Step,
  // Pulse,
  // Custom
};
 
template <typename T>
constexpr decltype(auto)
move_allow_trivial(T&& t) noexcept
{
  return std::move(t); // NOLINT
}
 
namespace Simulation::Feed
{
 
  struct Constant
  {
  };
 
  struct Exponential
  {
    double f0;
    double alpha;
  };
 
  struct Linear
  {
    double f0;
    double df;
  };
 
  // struct DelayedConstant
  // {
  //   double t_init;
  //   double t_end;
  //   double stored_value;
  // };
 
  // struct Step
  // {
  //   double t_init = 0.;
  // };
 
  // struct Pulse
  // {
  //   double t_init;
  //   double t_end;
  //   double frequency;
  //   double stored_value;
  // };
 
  // struct Custom
  // {
  // };
 
  // using FeedTypeVariant
  //     = std::variant<Constant, Step, Pulse, Custom, DelayedConstant>;
 
  using FeedTypeVariant = std::variant<Constant, Linear, Exponential>;
 
  FeedType get_type(const FeedTypeVariant& v);
 
  struct FeedValue
  {
    double concentration;
    std::size_t species_index;
  };
 
  struct FeedDescriptor
  {
    double flow{};
    std::vector<FeedValue> values;
    std::size_t input_position{};
    std::optional<std::size_t> output_position;
    FeedTypeVariant extra;
    bool use_relative_time = true;
    void update(double t, double d_t) noexcept;
  };
 
  struct FeedFactory
  {
    static FeedDescriptor constant(double flow,
                                   double concentration,
                                   std::size_t species_index,
                                   std::size_t input_position,
                                   std::optional<std::size_t> _ouput_position
                                   = std::nullopt,
                                   bool set_output = true);
 
    static FeedDescriptor sink(double flow, std::size_t _ouput_position);
 
    static FeedDescriptor linear(double flow,
                                 double df,
                                 double concentration,
                                 std::size_t species_index,
                                 std::size_t input_position,
                                 std::optional<std::size_t> _ouput_position
                                 = std::nullopt,
                                 bool set_output = true);
 
    static std::vector<FeedDescriptor> gas_feed(double concentration,
                                                std::size_t species_index,
                                                std::span<std::size_t> inlet_i,
                                                std::span<double> inlet_f,
                                                std::span<std::size_t> outlet_i,
                                                std::span<double> outlet_f,
                                                double tol = 1e-10);
  };
 
  class SimulationFeed
  {
  private:
    std::optional<std::vector<FeedDescriptor>> m_liquid;
    std::optional<std::vector<FeedDescriptor>> m_gas;
 
  public:
    void add_liquid(FeedDescriptor&& fd);
 
    void add_gas(FeedDescriptor&& fd);
 
    void add_feed(FeedDescriptor&& fd, Phase phase);
 
    [[nodiscard]] std::size_t n_liquid_flow() const noexcept;
    [[nodiscard]] std::size_t n_gas_flow() const noexcept;
 
    // [[nodiscard]] auto
    // liquid_feeds() const
    // {
    //   if (m_liquid)
    //   {
    //     return std::ranges::subrange(m_liquid->cbegin(), m_liquid->cend());
    //   }
    //   return std::ranges::subrange(
    //       std::vector<FeedDescriptor>::const_iterator(),
    //       std::vector<FeedDescriptor>::const_iterator());
    // }
 
    // [[nodiscard]] auto
    // gas_feeds() const
    // {
    //   if (m_gas)
    //   {
    //     return std::ranges::subrange(m_gas->cbegin(), m_gas->cend());
    //   }
    //   return std::ranges::subrange(
    //       std::vector<FeedDescriptor>::const_iterator(),
    //       std::vector<FeedDescriptor>::const_iterator());
    // }
    //
 
    [[nodiscard]] auto
    liquid_feeds() const
    {
      if (m_liquid)
      {
        return *m_liquid;
      }
      return std::vector<FeedDescriptor>();
    }
 
    [[nodiscard]] auto
    gas_feeds() const
    {
      if (m_gas)
      {
        return *m_gas;
      }
      return std::vector<FeedDescriptor>();
    }
 
    auto
    liquid_feeds()
    {
      if (m_liquid)
      {
        return std::ranges::subrange(m_liquid->begin(), m_liquid->end());
      }
      return std::ranges::subrange(std::vector<FeedDescriptor>::iterator(),
                                   std::vector<FeedDescriptor>::iterator());
    }
 
    auto
    gas_feeds()
    {
      if (m_gas)
      {
        return std::ranges::subrange(m_gas->begin(), m_gas->end());
      }
      return std::ranges::subrange(std::vector<FeedDescriptor>::iterator(),
                                   std::vector<FeedDescriptor>::iterator());
    }
 
    static SimulationFeed empty() noexcept;
  };
 
} // namespace Simulation::Feed
 
#endif