solver.hpp

Go to the documentation of this file.

#pragma once
/**
 * @file solver.hpp
 * @brief High-level solver orchestrating BCs and time integration.
 */
 
#include "types.hpp"
#include "grid.hpp"
#include "method.hpp"
#include <functional>
#include <memory>
#include <vector>
 
class HeatSolver {
public:
    /**
     * @brief Construct the solver with physical and numerical parameters and a scheme kind.
     * @param phys  Physical parameters (D [cm^2/h], L [cm], Tin, Tsur).
     * @param num   Numerical parameters (dx [cm], dt [h], tEnd [h], outEvery [h]).
     * @param scheme Selected time-stepping scheme (e.g. DuFort-Frankel).
     */
    HeatSolver(const PhysParams& phys, const NumParams& num, SchemeKind scheme);
 
    /**
     * @brief Run the simulation from t=0 to t=tEnd.
     * @param onDump Callback executed at t=0 and then every outEvery hours:
     *               onDump(time, grid, T).
     *               Use it to write CSV, compute errors, etc.
     */
    void run(const std::function<void(double,const Grid&,const std::vector<double>&)>& onDump);
 
private:
    PhysParams phys_;                       ///< Physical parameters (copied for convenience).
    NumParams  num_;                        ///< Numerical parameters (copied for convenience).
    Grid       grid_;                       ///< Spatial grid built from phys/num input.
    std::unique_ptr<Method> method_;        ///< Selected time integration method.
    bool uses_prev_step_ = false;           ///< True when the method requires T^{n-1}.
 
    std::vector<double> T_;                 ///< Current solution (typically holds T^n).
    std::vector<double> Tprev_;             ///< Previous solution (stores T^{n-1} when required).
    std::vector<double> next_;              ///< Buffer used to store the next time layer T^{n+1}.
 
    /**
     * @brief Apply Dirichlet boundary conditions (Tsur) at both ends of the vector.
     * @param T Temperature field updated in-place
     */
    void apply_dirichlet(std::vector<double>& T) const;
 
    /**
     * @brief Initialize the temperature field with Tin and enforce boundary conditions.
     */
    void init_field();
 
    /**
     * @brief Perform a warm-up step when the method needs two previous time levels.
     *
     * We call the scheme once with T^{n-1} = T^{n} = T^0 so that T_ holds T^1
     * while Tprev_ keeps a copy of T^0 (needed by three-level methods).
     */
    void bootstrap_if_needed();
};