sublimation.hpp

#ifndef ABLATELIBRARY_SUBLIMATION_HPP
#define ABLATELIBRARY_SUBLIMATION_HPP
 
#include "boundarySolver/boundaryProcess.hpp"
#include "boundarySolver/physics/subModels/sublimationModel.hpp"
#include "eos/radiationProperties/zimmer.hpp"
#include "eos/transport/transportModel.hpp"
#include "finiteVolume/processes/navierStokesTransport.hpp"
#include "finiteVolume/processes/pressureGradientScaling.hpp"
#include "io/interval/interval.hpp"
#include "radiation/surfaceRadiation.hpp"
 
namespace ablate::boundarySolver::physics {
 
class Sublimation : public BoundaryProcess, public io::Serializable {
   private:
    // static name of this model
    inline const static std::string sublimationId = "Sublimation";
 
    const std::shared_ptr<ablate::eos::transport::TransportModel> transportModel = nullptr;
    const std::shared_ptr<ablate::eos::EOS> eos;
    const std::shared_ptr<mathFunctions::MathFunction> additionalHeatFlux;
    PetscReal currentTime = 0.0;
 
    const std::shared_ptr<ablate::mathFunctions::FieldFunction> massFractions;
    const mathFunctions::PetscFunction massFractionsFunction;
    void *massFractionsContext;
    PetscInt numberSpecies = 0;
 
    const bool diffusionFlame;
 
    const std::shared_ptr<finiteVolume::processes::PressureGradientScaling> pressureGradientScaling;
 
    std::shared_ptr<ablate::radiation::SurfaceRadiation> radiation;
 
    eos::ThermodynamicTemperatureFunction effectiveConductivity;
 
    eos::ThermodynamicTemperatureFunction viscosityFunction;
 
    eos::ThermodynamicTemperatureFunction computeTemperatureFunction;
 
    eos::ThermodynamicTemperatureFunction computeSensibleEnthalpy;
 
    eos::ThermodynamicTemperatureFunction computePressure;
 
    const std::shared_ptr<io::interval::Interval> radiationInterval;
 
    const double emissivity;
 
    const double absorptivity;
 
    void UpdateSpecies(TS ts, ablate::solver::Solver &);
 
    std::shared_ptr<subModels::SublimationModel> sublimationModel = nullptr;
 
    // Hold onto a BoundaryPreRHSPointFunctionDefinition to precompute fe heat transfer if returned from the sublimation model
    BoundarySolver::BoundaryPreRHSPointFunctionDefinition solidHeatTransferUpdateFunctionDefinition{};
 
   public:
    explicit Sublimation(std::shared_ptr<subModels::SublimationModel> sublimationModel, std::shared_ptr<ablate::eos::transport::TransportModel> transportModel, std::shared_ptr<ablate::eos::EOS> eos,
                         const std::shared_ptr<ablate::mathFunctions::FieldFunction> & = {}, std::shared_ptr<mathFunctions::MathFunction> additionalHeatFlux = {},
                         std::shared_ptr<finiteVolume::processes::PressureGradientScaling> pressureGradientScaling = {}, bool diffusionFlame = false,
                         std::shared_ptr<ablate::radiation::SurfaceRadiation> radiationIn = {}, const std::shared_ptr<io::interval::Interval> &intervalIn = {},
                         const std::shared_ptr<ablate::parameters::Parameters> & = {});
 
    void Setup(ablate::boundarySolver::BoundarySolver &bSolver) override;
    void Initialize(ablate::boundarySolver::BoundarySolver &bSolver) override;
 
    void Setup(PetscInt numberSpecies);
 
    [[nodiscard]] const std::string &GetId() const override { return sublimationId; }
 
    [[nodiscard]] SerializerType Serialize() const override { return sublimationModel ? sublimationModel->Serialize() : io::Serializable::SerializerType::none; }
 
    PetscErrorCode Save(PetscViewer viewer, PetscInt sequenceNumber, PetscReal time) override {
        PetscFunctionBegin;
        PetscCall(sublimationModel->Save(viewer, sequenceNumber, time));
        PetscFunctionReturn(PETSC_SUCCESS);
    };
 
    PetscErrorCode Restore(PetscViewer viewer, PetscInt sequenceNumber, PetscReal time) override {
        PetscFunctionBegin;
        PetscCall(sublimationModel->Restore(viewer, sequenceNumber, time));
        PetscFunctionReturn(PETSC_SUCCESS);
    }
 
    static PetscErrorCode SublimationPreRHS(BoundarySolver &, TS ts, PetscReal time, bool initialStage, Vec locX, void *ctx);
 
    static PetscErrorCode SublimationFunction(PetscInt dim, const ablate::boundarySolver::BoundarySolver::BoundaryFVFaceGeom *fg, const PetscFVCellGeom *boundaryCell, const PetscInt uOff[],
                                              const PetscScalar *boundaryValues, const PetscScalar *stencilValues[], const PetscInt aOff[], const PetscScalar *auxValues,
                                              const PetscScalar *stencilAuxValues[], PetscInt stencilSize, const PetscInt stencil[], const PetscScalar stencilWeights[], const PetscInt sOff[],
                                              PetscScalar source[], void *ctx);
 
    static PetscErrorCode SublimationOutputFunction(PetscInt dim, const ablate::boundarySolver::BoundarySolver::BoundaryFVFaceGeom *fg, const PetscFVCellGeom *boundaryCell, const PetscInt uOff[],
                                                    const PetscScalar *boundaryValues, const PetscScalar *stencilValues[], const PetscInt aOff[], const PetscScalar *auxValues,
                                                    const PetscScalar *stencilAuxValues[], PetscInt stencilSize, const PetscInt stencil[], const PetscScalar stencilWeights[], const PetscInt sOff[],
                                                    PetscScalar source[], void *ctx);
 
    static PetscErrorCode UpdateBoundaryHeatTransferModel(PetscReal time, PetscReal dt, PetscInt dim, const ablate::boundarySolver::BoundarySolver::BoundaryFVFaceGeom *fg,
                                                          const PetscFVCellGeom *boundaryCell, const PetscInt uOff[], PetscScalar *boundaryValues, const PetscScalar *stencilValues[],
                                                          const PetscInt aOff[], PetscScalar *auxValues, const PetscScalar *stencilAuxValues[], PetscInt stencilSize, const PetscInt stencil[],
                                                          const PetscScalar stencilWeights[], void *ctx);
};
 
}  // namespace ablate::boundarySolver::physics
 
#endif  // ABLATELIBRARY_SUBLIMATION_HPP