116 lines
4.0 KiB
C++
116 lines
4.0 KiB
C++
#pragma once
|
|
|
|
#include "gridfire/engine/engine_abstract.h"
|
|
#include "gridfire/types/types.h"
|
|
|
|
#include <functional>
|
|
#include <any>
|
|
#include <vector>
|
|
#include <tuple>
|
|
#include <string>
|
|
|
|
namespace gridfire::solver {
|
|
template <typename EngineT>
|
|
concept IsEngine = std::is_base_of_v<engine::Engine, EngineT>;
|
|
|
|
struct SolverContextBase {
|
|
virtual void init() = 0;
|
|
virtual void set_stdout_logging(bool enable) = 0;
|
|
virtual void set_detailed_logging(bool enable) = 0;
|
|
virtual ~SolverContextBase() = default;
|
|
};
|
|
|
|
/**
|
|
* @struct TimestepContextBase
|
|
* @brief Base class for solver callback contexts.
|
|
*
|
|
* This struct serves as a base class for contexts that can be passed to solver callbacks, it enforces
|
|
* that derived classes implement a `describe` method that returns a vector of tuples describing
|
|
* the context that a callback will receive when called.
|
|
*/
|
|
class TimestepContextBase {
|
|
public:
|
|
virtual ~TimestepContextBase() = default;
|
|
|
|
/**
|
|
* @brief Describe the context for callback functions.
|
|
* @return A vector of tuples, each containing a string for the parameters name and a string for its type.
|
|
*
|
|
* This method should be overridden by derived classes to provide a description of the context
|
|
* that will be passed to the callback function. The intent of this method is that an end user can investigate
|
|
* the context that will be passed to the callback function, and use this information to craft their own
|
|
* callback function.
|
|
*/
|
|
[[nodiscard]] virtual std::vector<std::tuple<std::string, std::string>> describe() const = 0;
|
|
};
|
|
/**
|
|
* @class SingleZoneNetworkSolver
|
|
* @brief Abstract base class for network solver strategies.
|
|
*
|
|
* This class defines the interface for network solver strategies, which are responsible
|
|
* for integrating the reaction network ODEs over a given timestep. It is templated on the
|
|
* engine type to allow for different engine implementations to be used with the same solver.
|
|
*
|
|
* @tparam EngineT The type of engine to use with this solver strategy. Must inherit from Engine.
|
|
*/
|
|
template <IsEngine EngineT>
|
|
class SingleZoneNetworkSolver {
|
|
public:
|
|
/**
|
|
* @brief Constructor for the NetworkSolverStrategy.
|
|
* @param engine The engine to use for evaluating the network.
|
|
*/
|
|
explicit SingleZoneNetworkSolver(
|
|
const EngineT& engine
|
|
) :
|
|
m_engine(engine) {};
|
|
|
|
/**
|
|
* @brief Virtual destructor.
|
|
*/
|
|
virtual ~SingleZoneNetworkSolver() = default;
|
|
|
|
/**
|
|
* @brief Evaluates the network for a given timestep.
|
|
* @param solver_ctx
|
|
* @param engine_ctx
|
|
* @param netIn The input conditions for the network.
|
|
* @return The output conditions after the timestep.
|
|
*/
|
|
virtual NetOut evaluate(
|
|
SolverContextBase& solver_ctx,
|
|
const NetIn& netIn
|
|
) const = 0;
|
|
|
|
protected:
|
|
const EngineT& m_engine; ///< The engine used by this solver strategy.
|
|
};
|
|
|
|
template <IsEngine EngineT>
|
|
class MultiZoneNetworkSolver {
|
|
public:
|
|
explicit MultiZoneNetworkSolver(
|
|
const EngineT& engine,
|
|
const SingleZoneNetworkSolver<EngineT>& solver
|
|
) :
|
|
m_engine(engine),
|
|
m_solver(solver) {};
|
|
|
|
virtual ~MultiZoneNetworkSolver() = default;
|
|
|
|
virtual std::vector<NetOut> evaluate(
|
|
SolverContextBase& solver_ctx,
|
|
const std::vector<NetIn>& netIns
|
|
) const = 0;
|
|
protected:
|
|
const EngineT& m_engine; ///< The engine used by this solver strategy.
|
|
const SingleZoneNetworkSolver<EngineT>& m_solver;
|
|
};
|
|
|
|
/**
|
|
* @brief Type alias for a network solver strategy that uses a DynamicEngine.
|
|
*/
|
|
using SingleZoneDynamicNetworkSolver = SingleZoneNetworkSolver<engine::DynamicEngine>;
|
|
using MultiZoneDynamicNetworkSolver = MultiZoneNetworkSolver<engine::DynamicEngine>;
|
|
}
|