method.hpp

Go to the documentation of this file.

#ifndef METHOD_HPP
#define METHOD_HPP
 
#include "grid.hpp"
#include <memory>
#include <string>
#include <vector>
 
/**
 * @brief Enumeration of the numerical schemes available in the solver.
 */
enum class SchemeKind
{
    Richardson,    ///< Central time, central space (explicit, unstable).
    DuFortFrankel, ///< Modified Richardson (explicit, stable).
    Laasonen,      ///< Simple Implicit (forward time, central space).
    CrankNicolson  ///< Trapezoidal Implicit (second order accuracy).
};
 
/**
 * @class Method
 * @brief Abstract interface for time-integration schemes solving the 1D heat equation.
 *
 * This interface abstracts away the difference between explicit/implicit schemes
 * and 2-level/3-level time stepping schemes.
 */
class Method
{
  public:
    virtual ~Method() = default;
 
    /**
     * @brief Get human-readable name of the scheme.
     */
    virtual std::string name() const = 0;
 
    /**
     * @brief Computes the temperature field at the next time step (T^{n+1}).
     *
     * @param g     Grid metadata (spacing dx and node count Nx).
     * @param D     Thermal diffusivity [cm^2/h].
     * @param dt    Time step size [h].
     * @param Tprev Temperature at time step n-1 (Read-only).
     * Required only for 3-level schemes (Richardson, DuFort-Frankel).
     * For 2-level schemes, this vector may be ignored.
     * @param Tcurr Temperature at time step n (Read-only).
     * @param Tnext Output vector to be filled with temperature at time step n+1.
     */
    virtual void step(const Grid& g,
                      double D,
                      double dt,
                      const std::vector<double>& Tprev,
                      const std::vector<double>& Tcurr,
                      std::vector<double>& Tnext) const = 0;
 
    /**
     * @brief Indicates if the scheme requires data from time step n-1.
     *
     * @return true  For 3-level schemes (e.g., Richardson, DuFort-Frankel).
     * @return false For 2-level schemes (e.g., Laasonen, Crank-Nicolson).
     */
    virtual bool uses_previous_step() const = 0;
};
 
/**
 * @brief Factory function to create a concrete method instance.
 *
 * @param scheme The type of numerical scheme requested.
 * @return std::unique_ptr<Method> Pointer to the created solver method.
 */
std::unique_ptr<Method> make_method(SchemeKind scheme);
 
#endif // METHOD_HPP