engine_abstract.h

Go to the documentation of this file.

#pragma once
 
#include "gridfire/reaction/reaction.h"
#include "gridfire/network.h"
#include "gridfire/screening/screening_abstract.h"
#include "gridfire/screening/screening_types.h"
 
#include "gridfire/engine/types/reporting.h"
#include "gridfire/engine/types/building.h"
 
#include "gridfire/expectations/expected_engine.h"
 
#include <vector>
#include <unordered_map>
#include <utility>
#include <expected>

 
namespace gridfire {

    template<typename T>
    concept IsArithmeticOrAD = std::is_same_v<T, double> || std::is_same_v<T, CppAD::AD<double>>;

    template <IsArithmeticOrAD T>
    struct StepDerivatives {
        std::vector<T> dydt; 
        T nuclearEnergyGenerationRate = T(0.0); 
    };
 
    using SparsityPattern = std::vector<std::pair<size_t, size_t>>;

    class Engine {
    public:
        virtual ~Engine() = default;

        [[nodiscard]] virtual const std::vector<fourdst::atomic::Species>& getNetworkSpecies() const = 0;

        [[nodiscard]] virtual std::expected<StepDerivatives<double>, expectations::StaleEngineError> calculateRHSAndEnergy(
            const std::vector<double>& Y,
            double T9,
            double rho
        ) const = 0;
    };

    class DynamicEngine : public Engine {
    public:
        virtual void generateJacobianMatrix(
            const std::vector<double>& Y_dynamic,
            double T9,
            double rho
        ) const = 0;
 
        virtual void generateJacobianMatrix(
            const std::vector<double>& Y_dynamic,
            double T9,
            double rho,
            const SparsityPattern& sparsityPattern
        ) const {
            throw std::logic_error("Sparsity pattern not supported by this engine.");
        }

        [[nodiscard]] virtual double getJacobianMatrixEntry(
            int i,
            int j
        ) const = 0;
 

        virtual void generateStoichiometryMatrix() = 0;

        [[nodiscard]] virtual int getStoichiometryMatrixEntry(
            int speciesIndex,
            int reactionIndex
        ) const = 0;

        [[nodiscard]] virtual double calculateMolarReactionFlow(
            const reaction::Reaction& reaction,
            const std::vector<double>& Y,
            double T9,
            double rho
        ) const = 0;

        [[nodiscard]] virtual const reaction::LogicalReactionSet& getNetworkReactions() const = 0;
 
        virtual void setNetworkReactions(const reaction::LogicalReactionSet& reactions) = 0;

        [[nodiscard]] virtual std::expected<std::unordered_map<fourdst::atomic::Species, double>, expectations::StaleEngineError> getSpeciesTimescales(
            const std::vector<double>& Y,
            double T9,
            double rho
        ) const = 0;
 
        [[nodiscard]] virtual std::expected<std::unordered_map<fourdst::atomic::Species, double>, expectations::StaleEngineError> getSpeciesDestructionTimescales(
            const std::vector<double>& Y,
            double T9,
            double rho
        ) const = 0;

        virtual fourdst::composition::Composition update(const NetIn &netIn) = 0;
 
        virtual bool isStale(const NetIn& netIn) = 0;

        virtual void setScreeningModel(screening::ScreeningType model) = 0;

        [[nodiscard]] virtual screening::ScreeningType getScreeningModel() const = 0;
 
        [[nodiscard]] virtual int getSpeciesIndex(const fourdst::atomic::Species &species) const = 0;
 
        [[nodiscard]] virtual std::vector<double> mapNetInToMolarAbundanceVector(const NetIn &netIn) const = 0;
 
        [[nodiscard]] virtual PrimingReport primeEngine(const NetIn &netIn) = 0;
 
        [[nodiscard]] virtual BuildDepthType getDepth() const {
            throw std::logic_error("Network depth not supported by this engine.");
        }
 
        virtual void rebuild(const fourdst::composition::Composition& comp, BuildDepthType depth) {
            throw std::logic_error("Setting network depth not supported by this engine.");
        }
 
    };
}