solver.hpp

#ifndef ABLATELIBRARY_SOLVER_HPP
#define ABLATELIBRARY_SOLVER_HPP
 
#include <domain/region.hpp>
#include <domain/subDomain.hpp>
#include <functional>
#include <parameters/parameters.hpp>
#include <string>
#include <vector>
#include "domain/range.hpp"
#include "io/serializable.hpp"
 
namespace ablate::solver {
 
class TimeStepper;
 
class Solver {
   private:
    // pre and post step functions for the flow
    std::vector<std::function<void(TS ts, Solver&)>> preStepFunctions;
    std::vector<std::function<void(TS ts, Solver&, PetscReal)>> preStageFunctions;
    std::vector<std::function<void(TS ts, Solver&)>> postStepFunctions;
    std::vector<std::function<void(TS ts, Solver&)>> postEvaluateFunctions;
 
    // The name of this solver
    const std::string solverId;
 
    // The region of this solver.
    const std::shared_ptr<domain::Region> region;
 
   protected:
    // an optional petscOptions that is used for this solver
    PetscOptions petscOptions;
 
    // use the subDomain to setup the problem
    std::shared_ptr<ablate::domain::SubDomain> subDomain;
 
    // The constructor to be call by any Solve implementation
    explicit Solver(std::string solverId, std::shared_ptr<domain::Region> = {}, std::shared_ptr<parameters::Parameters> options = nullptr);
 
    // Replacement calls for PETSC versions allowing multiple DS
    static PetscErrorCode DMPlexInsertBoundaryValues_Plex(DM dm, PetscDS ds, PetscBool insertEssential, Vec locX, PetscReal time, Vec faceGeomFVM, Vec cellGeomFVM, Vec gradFVM);
    static PetscErrorCode DMPlexInsertTimeDerivativeBoundaryValues_Plex(DM dm, PetscDS ds, PetscBool insertEssential, Vec locX, PetscReal time, Vec faceGeomFVM, Vec cellGeomFVM, Vec gradFVM);
 
   public:
    virtual ~Solver();
 
    virtual void Register(std::shared_ptr<ablate::domain::SubDomain> subDomain);
 
    virtual void Setup() = 0;
 
    /*** Set up mesh dependent initialization, this may be called multiple times if the mesh changes **/
    virtual void Initialize() = 0;
 
    [[nodiscard]] inline const std::string& GetSolverId() const { return solverId; }
 
    inline ablate::domain::SubDomain& GetSubDomain() noexcept { return *subDomain; }
 
    [[nodiscard]] inline const ablate::domain::SubDomain& GetSubDomain() const noexcept { return *subDomain; }
 
    [[nodiscard]] inline std::shared_ptr<domain::Region> GetRegion() const noexcept { return region; }
 
    // Support for timestepping calls
    void PreStage(TS ts, PetscReal stagetime);
    void PreStep(TS ts);
    void PostStep(TS ts);
    void PostEvaluate(TS ts);
 
    inline void RegisterPreStep(const std::function<void(TS ts, Solver&)>& preStep) { this->preStepFunctions.push_back(preStep); }
 
    inline void RegisterPreStage(const std::function<void(TS ts, Solver&, PetscReal)>& preStage) { this->preStageFunctions.push_back(preStage); }
 
    inline void RegisterPostStep(const std::function<void(TS ts, Solver&)>& postStep) { this->postStepFunctions.push_back(postStep); }
 
    inline void RegisterPostEvaluate(const std::function<void(TS ts, Solver&)>& postEval) { this->postEvaluateFunctions.push_back(postEval); }
 
    void GetCellRange(ablate::domain::Range& cellRange) const { this->subDomain->GetCellRange(this->GetRegion(), cellRange); };
 
    void GetFaceRange(ablate::domain::Range& faceRange) const { this->subDomain->GetFaceRange(this->GetRegion(), faceRange); }
 
    void GetRange(PetscInt depth, ablate::domain::Range& range) const { this->subDomain->GetRange(this->GetRegion(), depth, range); }
 
    void RestoreRange(ablate::domain::Range& range) const { this->subDomain->RestoreRange(range); }
};
 
}  // namespace ablate::solver
#endif  // ABLATELIBRARY_SOLVER_HPP