engine_defined.h

Go to the documentation of this file.

#pragma once
 
#include "gridfire/engine/views/engine_view_abstract.h"
#include "gridfire/engine/engine_abstract.h"
#include "gridfire/io/network_file.h"
#include "gridfire/network.h"
 
#include "fourdst/config/config.h"
#include "fourdst/logging/logging.h"
 
#include "quill/Logger.h"
 
#include <string>
 
namespace gridfire{
    class DefinedEngineView : public DynamicEngine, public EngineView<DynamicEngine> {
    public:
        DefinedEngineView(const std::vector<std::string>& peNames, DynamicEngine& baseEngine);
        const DynamicEngine& getBaseEngine() const override;
 
        // --- Engine Interface ---
        const std::vector<fourdst::atomic::Species>& getNetworkSpecies() const override;
 
        // --- DynamicEngine Interface ---
        std::expected<StepDerivatives<double>, expectations::StaleEngineError> calculateRHSAndEnergy(
            const std::vector<double>& Y_defined,
            const double T9,
            const double rho
        ) const override;
        void generateJacobianMatrix(
            const std::vector<double>& Y_dynamic,
            const double T9,
            const double rho
        ) const override;
        double getJacobianMatrixEntry(
            const int i_defined,
            const int j_defined
        ) const override;
        void generateStoichiometryMatrix() override;
        int getStoichiometryMatrixEntry(
            const int speciesIndex_defined,
            const int reactionIndex_defined
        ) const override;
        double calculateMolarReactionFlow(
            const reaction::Reaction& reaction,
            const std::vector<double>& Y_defined,
            const double T9,
            const double rho
        ) const override;
        const reaction::LogicalReactionSet& getNetworkReactions() const override;
 
        void setNetworkReactions(const reaction::LogicalReactionSet& reactions) override;
        [[nodiscard]] std::expected<std::unordered_map<fourdst::atomic::Species, double>, expectations::StaleEngineError> getSpeciesTimescales(
            const std::vector<double>& Y_defined,
            const double T9,
            const double rho
        ) const override;
 
        [[nodiscard]] std::expected<std::unordered_map<fourdst::atomic::Species, double>, expectations::StaleEngineError> getSpeciesDestructionTimescales(
            const std::vector<double>& Y_defined,
            const double T9,
            const double rho
        ) const override;

        fourdst::composition::Composition update(const NetIn &netIn) override;
 
        bool isStale(const NetIn& netIn) override;

        void setScreeningModel(screening::ScreeningType model) override;

        [[nodiscard]] screening::ScreeningType getScreeningModel() const override;
 
        [[nodiscard]] int getSpeciesIndex(const fourdst::atomic::Species &species) const override;
 
        [[nodiscard]] std::vector<double> mapNetInToMolarAbundanceVector(const NetIn &netIn) const override;
 
        [[nodiscard]] PrimingReport primeEngine(const NetIn &netIn) override;
    protected:
        bool m_isStale = true;
        DynamicEngine& m_baseEngine;
    private:
        quill::Logger* m_logger = fourdst::logging::LogManager::getInstance().getLogger("log"); 
        std::vector<fourdst::atomic::Species> m_activeSpecies;
        reaction::LogicalReactionSet m_activeReactions;

        std::vector<size_t> m_speciesIndexMap;
        std::vector<size_t> m_reactionIndexMap;
    private:
        std::vector<size_t> constructSpeciesIndexMap() const;

        std::vector<size_t> constructReactionIndexMap() const;

        std::vector<double> mapViewToFull(const std::vector<double>& defined) const;

        std::vector<double> mapFullToView(const std::vector<double>& full) const;

        size_t mapViewToFullSpeciesIndex(size_t definedSpeciesIndex) const;

        size_t mapViewToFullReactionIndex(size_t definedReactionIndex) const;
 
        void validateNetworkState() const;
 
        void collect(const std::vector<std::string>& peNames);
 
    };
 
    class FileDefinedEngineView final: public DefinedEngineView {
    public:
        explicit FileDefinedEngineView(
            DynamicEngine& baseEngine,
            const std::string& fileName,
            const io::NetworkFileParser& parser
        );
        std::string getNetworkFile() const { return m_fileName; }
        const io::NetworkFileParser& getParser() const { return m_parser; }
    private:
        using Config = fourdst::config::Config;
        using LogManager = fourdst::logging::LogManager;
        Config& m_config = Config::getInstance();
        quill::Logger* m_logger = LogManager::getInstance().getLogger("log");
        std::string m_fileName;
        const io::NetworkFileParser& m_parser;
    };
}