solver.h

Go to the documentation of this file.

#pragma once
 
#include "gridfire/engine/engine_graph.h"
#include "gridfire/engine/engine_abstract.h"
#include "../engine/views/engine_adaptive.h"
#include "gridfire/network.h"
 
#include "fourdst/logging/logging.h"
#include "fourdst/config/config.h"
 
#include "quill/Logger.h"
 
#include <vector>
 
namespace gridfire::solver {
    template <typename EngineT>
    class NetworkSolverStrategy {
    public:
        explicit NetworkSolverStrategy(EngineT& engine) : m_engine(engine) {};

        virtual ~NetworkSolverStrategy() = default;

        virtual NetOut evaluate(const NetIn& netIn) = 0;
    protected:
        EngineT& m_engine; 
    };

    using DynamicNetworkSolverStrategy = NetworkSolverStrategy<DynamicEngine>;

    class DirectNetworkSolver final : public DynamicNetworkSolverStrategy {
    public:
        using DynamicNetworkSolverStrategy::DynamicNetworkSolverStrategy;

        NetOut evaluate(const NetIn& netIn) override;
    private:
        struct RHSManager {
            DynamicEngine& m_engine; 
            const double m_T9; 
            const double m_rho; 
 
            mutable double m_cached_time;
            mutable std::optional<StepDerivatives<double>> m_cached_result;
 
            mutable double m_last_observed_time = 0.0; 
 
 
            quill::Logger* m_logger = LogManager::getInstance().newFileLogger("integration.log", "GridFire"); 
            mutable int m_num_steps = 0;
            mutable double m_last_step_time = 1e-20;

            RHSManager(
                DynamicEngine& engine,
                const double T9,
                const double rho
            ) :
            m_engine(engine),
            m_T9(T9),
            m_rho(rho),
            m_cached_time(0) {}

            void operator()(
                const boost::numeric::ublas::vector<double>& Y,
                boost::numeric::ublas::vector<double>& dYdt,
                double t
            ) const;
 
            void observe(const boost::numeric::ublas::vector<double>& state, double t) const;
            void compute_and_cache(const boost::numeric::ublas::vector<double>& state, double t) const;
 
        };

        struct JacobianFunctor {
            DynamicEngine& m_engine; 
            const double m_T9; 
            const double m_rho; 

            JacobianFunctor(
                DynamicEngine& engine,
                const double T9,
                const double rho
            ) :
            m_engine(engine),
            m_T9(T9),
            m_rho(rho) {}

            void operator()(
                const boost::numeric::ublas::vector<double>& Y,
                boost::numeric::ublas::matrix<double>& J,
                double t,
                boost::numeric::ublas::vector<double>& dfdt
            ) const;
 
        };
 
    private:
        quill::Logger* m_logger = LogManager::getInstance().getLogger("log"); 
        Config& m_config = Config::getInstance(); 
    };
}