solver.hpp

#pragma once
 
#include <string>
#include <memory>
#include <string>
#include <armadillo>
 
class Config;
class Physics;
class BatchTracking;
class Pipeline;
class GoverningEquationSolverBase;
class BoundaryConditions;
class TimeStep;
 
class Solver
{
public:
    virtual ~Solver();
 
    Solver(
            const arma::uword nGridPoints,
            const Config& config);
 
    explicit Solver(
            const arma::uword nGridPoints,
            const std::string& energyEquation = "InternalEnergy",
            const arma::vec& relaxationFactors = {1, 1, 2/3.0},
            const std::string& toleranceType = "relative",
            const arma::vec& tolerances = {0.001, 0.001, 0.001},
            const bool bruteForce = false,
            const arma::uword maxIterations = 200);
 
    virtual Pipeline solve(
            const arma::uword dt,
            const Pipeline& current,
            const TimeStep& boundaryConditions,
            const Physics& physics) const;
 
    virtual Pipeline solve(
            const arma::uword dt,
            const Pipeline& current,
            const BoundaryConditions& boundaryConditions,
            const Physics& physics) const;
 
    static arma::uword differencesWithinTolerance(
            const Pipeline& guess,
            const Pipeline& previous,
            const arma::vec& tolerances,
            const std::string& toleranceType,
            const arma::vec& relaxationFactors);
 
    Pipeline solveWithIterations(
            const arma::uword dt,
            const Pipeline& current,
            const BoundaryConditions& boundaryConditions,
            const Physics& physics) const;
 
    void enableBruteForce();
 
    void setMaxIterations(const arma::uword maxIterations);
 
    arma::uword nIterations() const { return m_nIterations; }
 
    const arma::vec& relaxationFactors() const { return m_relaxationFactor;}
    const std::string& toleranceType() const { return m_toleranceType; }
    const arma::vec& tolerances() const { return m_tolerances; }
    const GoverningEquationSolverBase& governingEquationSolver() const { return *m_governingEquationSolver; }
 
private:
    arma::vec m_relaxationFactor;
 
    std::string m_toleranceType;
 
    arma::vec m_tolerances;
 
//    arma::uword m_maxNumberOfIterations = 20; // not used
//    bool m_hardLimitOnNumberOfIterations = true; // not used
//    bool m_bruteForce = false; // not used
 
    bool m_bruteForce;
    arma::uword m_maxIterations;
    mutable arma::uword m_nIterations = 0;
 
    std::unique_ptr<GoverningEquationSolverBase> m_governingEquationSolver;
 
    std::unique_ptr<BatchTracking> m_compositionSolver;
 
    std::unique_ptr<GoverningEquationSolverBase> makeGoverningEquationSolver(
            const arma::uword nGridPoints,
            const Config& config);
 
    std::unique_ptr<GoverningEquationSolverBase> makeGoverningEquationSolver(
            const arma::uword nGridPoints,
            const std::string& discretizer);
};