finiteVolumeSolver.hpp

#ifndef ABLATELIBRARY_FINITEVOLUMESOLVER_HPP
#define ABLATELIBRARY_FINITEVOLUMESOLVER_HPP
 
#include <string>
#include <vector>
#include "boundaryConditions/boundaryCondition.hpp"
#include "cellInterpolant.hpp"
#include "eos/eos.hpp"
#include "faceInterpolant.hpp"
#include "mathFunctions/fieldFunction.hpp"
#include "solver/cellSolver.hpp"
#include "solver/solver.hpp"
#include "solver/timeStepper.hpp"
#include "utilities/vectorUtilities.hpp"
 
namespace ablate::finiteVolume {
 
// forward declare the FlowProcesses
namespace processes {
class Process;
}
 
class FiniteVolumeSolver : public solver::CellSolver,
                           public solver::RHSFunction,
                           public io::Serializable,
                           public solver::BoundaryFunction,
                           public solver::PhysicsTimeStepFunction,
                           private utilities::Loggable<FiniteVolumeSolver> {
   public:
    using PreRHSFunctionDefinition = PetscErrorCode (*)(FiniteVolumeSolver&, TS ts, PetscReal time, bool initialStage, Vec locX, void* ctx);
    using RHSArbitraryFunction = PetscErrorCode (*)(const FiniteVolumeSolver&, DM dm, PetscReal time, Vec locXVec, Vec locFVec, void* ctx);
    using ComputeTimeStepFunction = double (*)(TS ts, FiniteVolumeSolver&, void* ctx);
 
    enum MeshCharacteristics { MIN_CELL_RADIUS = 0, MAX_CELL_RADIUS };
 
   private:
    struct ComputeTimeStepDescription {
        ComputeTimeStepFunction function;
        void* context;
        std::string name; 
    };
 
    // hold the update functions for flux and point sources
    std::vector<CellInterpolant::DiscontinuousFluxFunctionDescription> discontinuousFluxFunctionDescriptions;
    std::vector<FaceInterpolant::ContinuousFluxFunctionDescription> continuousFluxFunctionDescriptions;
    std::vector<CellInterpolant::PointFunctionDescription> pointFunctionDescriptions;
 
    // allow the use of any arbitrary rhs functions
    std::vector<std::pair<RHSArbitraryFunction, void*>> rhsArbitraryFunctions;
 
    // allow the use of any arbitrary pre rhs functions
    std::vector<std::pair<PreRHSFunctionDefinition, void*>> preRhsFunctions;
 
    // functions to update the timestep
    std::vector<ComputeTimeStepDescription> timeStepFunctions;
 
    // Hold the flow processes.  This is mostly just to hold a pointer to them
    std::vector<std::shared_ptr<processes::Process>> processes;
 
    // store the boundary conditions
    const std::vector<std::shared_ptr<boundaryConditions::BoundaryCondition>> boundaryConditions;
 
    std::unique_ptr<FaceInterpolant> faceInterpolant = nullptr;
 
    std::unique_ptr<CellInterpolant> cellInterpolant = nullptr;
 
    std::shared_ptr<domain::Region> solverRegionMinusGhost;
 
    DM meshCharacteristicsDm = nullptr;
 
    Vec meshCharacteristicsLocalVec = nullptr;
 
   public:
    FiniteVolumeSolver(std::string solverId, std::shared_ptr<domain::Region>, std::shared_ptr<parameters::Parameters> options, std::vector<std::shared_ptr<processes::Process>> flowProcesses,
                       std::vector<std::shared_ptr<boundaryConditions::BoundaryCondition>> boundaryConditions);
 
    ~FiniteVolumeSolver() override;
 
    void Setup() override;
    void Initialize() override;
 
    PetscErrorCode ComputeRHSFunction(PetscReal time, Vec locXVec, Vec locFVec) override;
 
    PetscErrorCode ComputeBoundary(PetscReal time, Vec locX, Vec locX_t) override;
 
    void RegisterRHSFunction(CellInterpolant::DiscontinuousFluxFunction function, void* context, const std::string& field, const std::vector<std::string>& inputFields,
                             const std::vector<std::string>& auxFields);
 
    void RegisterRHSFunction(FaceInterpolant::ContinuousFluxFunction function, void* context, const std::string& field, const std::vector<std::string>& inputFields,
                             const std::vector<std::string>& auxFields);
 
    void RegisterRHSFunction(CellInterpolant::PointFunction function, void* context, const std::vector<std::string>& fields, const std::vector<std::string>& inputFields,
                             const std::vector<std::string>& auxFields);
 
    void RegisterRHSFunction(RHSArbitraryFunction function, void* context);
 
    void RegisterPreRHSFunction(PreRHSFunctionDefinition function, void* context);
 
    void RegisterComputeTimeStepFunction(ComputeTimeStepFunction function, void* ctx, std::string name);
 
    std::map<std::string, double> ComputePhysicsTimeSteps(TS) override;
 
    double ComputePhysicsTimeStep(TS) override;
 
    SerializerType Serialize() const override;
 
    const std::string& GetId() const override { return GetSolverId(); }
 
    PetscErrorCode Save(PetscViewer viewer, PetscInt sequenceNumber, PetscReal time) override;
 
    PetscErrorCode Restore(PetscViewer viewer, PetscInt sequenceNumber, PetscReal time) override;
 
    void GetCellRangeWithoutGhost(ablate::domain::Range& faceRange) const;
 
    template <class T>
    std::shared_ptr<T> FindProcess() {
        return utilities::VectorUtilities::Find<T>(processes);
    }
 
    PetscErrorCode PreRHSFunction(TS ts, PetscReal time, bool initialStage, Vec locX) override;
 
    inline void GetMeshCharacteristics(DM& dm, Vec& vec) {
        dm = meshCharacteristicsDm;
        vec = meshCharacteristicsLocalVec;
    }
};
}  // namespace ablate::finiteVolume
 
#endif  // ABLATELIBRARY_FINITEVOLUMESOLVER_HPP