chemTab.hpp

#ifndef ABLATELIBRARY_CHEMTAB_HPP
#define ABLATELIBRARY_CHEMTAB_HPP
 
#include <petscmat.h>
#include <filesystem>
#include <istream>
#include "chemistryModel.hpp"
#include "eos/tChem.hpp"
#ifdef WITH_TENSORFLOW
#include <tensorflow/c/c_api.h>
#include "finiteVolume/compressibleFlowFields.hpp"
#include "utilities/vectorUtilities.hpp"
#endif
 
namespace ablate::eos {
 
#ifdef WITH_TENSORFLOW
class ChemTab : public ChemistryModel, public std::enable_shared_from_this<ChemTab>, public utilities::Loggable<ChemTab> {
   public:
    inline const static std::string DENSITY_YI_DECODE_FIELD = "DENSITY_YI_DECODE";
 
   private:
    std::shared_ptr<ablate::eos::TChem> referenceEOS;
 
    // hold the required tensorflow information
    TF_Graph* graph = nullptr;
    TF_Status* status = nullptr;
    TF_SessionOptions* sessionOpts = nullptr;
    TF_Buffer* runOpts = nullptr;
    TF_Session* session = nullptr;
    std::vector<std::string> speciesNames = std::vector<std::string>(0);
    std::vector<std::string> progressVariablesNames = std::vector<std::string>(0);
 
    PetscReal** Wmat = nullptr;
 
    // Store any initializers specified by the metadata
    std::map<std::string, std::map<std::string, double>> initializers;
 
    void ExtractMetaData(std::istream& inputStream);
    static void LoadBasisVectors(std::istream& inputStream, std::size_t columns, PetscReal** W);
 
    void ChemTabModelComputeFunction(PetscReal density, const PetscReal densityProgressVariables[], PetscReal* densityEnergySource, PetscReal* densityProgressVariableSource,
                                     PetscReal* densityMassFractions) const;
 
    void ChemTabModelComputeFunction(const PetscReal density[], const PetscReal* const* const densityProgressVariables, PetscReal** densityEnergySource, PetscReal** densityProgressVariableSource,
                                     PetscReal** densityMassFractions, size_t batch_size) const;
 
    [[nodiscard]] std::vector<std::string> GetFieldTags() const override { return std::vector<std::string>{ablate::finiteVolume::CompressibleFlowFields::MinusOneToOneRange}; }
 
    class ChemTabSourceCalculator : public ChemistryModel::SourceCalculator {
       private:
        const PetscInt densityOffset;
        const PetscInt densityEnergyOffset;
        const PetscInt densityProgressVariableOffset;
        const std::shared_ptr<ChemTab> chemTabModel;
 
       public:
        ChemTabSourceCalculator(PetscInt densityOffset, PetscInt densityEnergyOffset, PetscInt densityProgressVariableOffset, std::shared_ptr<ChemTab> chemTabModel);
 
        void ComputeSource(const ablate::domain::Range& cellRange, PetscReal time, PetscReal dt, Vec solution) override{};
 
        void AddSource(const ablate::domain::Range& cellRange, Vec locSolution, Vec locSource) override;
    };
 
    void ComputeProgressVariables(const PetscReal* massFractions, PetscReal* progressVariables) const;
 
    void ComputeProgressVariables(const PetscReal* const* massFractions, PetscReal* const* progressVariables, size_t n) const;
 
    static PetscErrorCode ComputeMassFractions(PetscReal time, PetscInt dim, const PetscFVCellGeom* cellGeom, const PetscInt uOff[], PetscScalar* u, void* ctx);
 
   public:
    explicit ChemTab(const std::filesystem::path& path);
    ~ChemTab() override;
 
    [[nodiscard]] const std::vector<std::string>& GetSpeciesVariables() const override { return ablate::utilities::VectorUtilities::Empty<std::string>; }
 
    [[nodiscard]] const std::vector<std::string>& GetSpeciesNames() const { return speciesNames; }
 
    [[nodiscard]] const std::vector<std::string>& GetFieldFunctionProperties() const override { return progressVariablesNames; }
 
    [[nodiscard]] const std::vector<std::string>& GetProgressVariables() const override { return progressVariablesNames; }
 
    std::vector<std::shared_ptr<domain::FieldDescriptor>> GetAdditionalFields() const override;
 
    void ChemistrySource(const PetscReal density, const PetscReal densityProgressVariable[], PetscReal* densityEnergySource, PetscReal* densityProgressVariableSource) const;
 
    void ChemistrySource(const PetscReal* const density, const PetscReal* const* const densityProgressVariable, PetscReal** densityEnergySource, PetscReal** progressVariableSource, size_t n) const;
 
    std::shared_ptr<SourceCalculator> CreateSourceCalculator(const std::vector<domain::Field>& fields, const ablate::domain::Range& cellRange) override;
 
    void View(std::ostream& stream) const override;
 
    [[nodiscard]] eos::ThermodynamicFunction GetThermodynamicFunction(eos::ThermodynamicProperty property, const std::vector<domain::Field>& fields) const override;
 
    [[nodiscard]] eos::ThermodynamicTemperatureFunction GetThermodynamicTemperatureFunction(eos::ThermodynamicProperty property, const std::vector<domain::Field>& fields) const override;
 
    [[nodiscard]] eos::EOSFunction GetFieldFunctionFunction(const std::string& field, eos::ThermodynamicProperty property1, eos::ThermodynamicProperty property2,
                                                            std::vector<std::string> otherProperties) const override;
 
    void ComputeProgressVariables(const std::vector<PetscReal>& massFractions, std::vector<PetscReal>& progressVariables) const;
 
    void ComputeMassFractions(std::vector<PetscReal>& progressVariables, std::vector<PetscReal>& massFractions, PetscReal density = 1.0) const;
 
    void ComputeMassFractions(const PetscReal* densityProgressVariables, PetscReal* densityMassFractions, const PetscReal density = 1.0) const;
 
    void ComputeMassFractions(const PetscReal* const* densityProgressVariables, PetscReal** densityMassFractions, const PetscReal density[], size_t n) const;
 
    void GetInitializerProgressVariables(const std::string& name, std::vector<PetscReal>& progressVariables) const;
 
    [[nodiscard]] std::vector<std::tuple<ablate::solver::CellSolver::SolutionFieldUpdateFunction, void*, std::vector<std::string>>> GetSolutionFieldUpdates() override;
 
    void ExtractModelOutputsAtPoint(const PetscReal density, PetscReal* densityEnergySource, PetscReal* densityProgressVariableSource, PetscReal* densityMassFractions,
                                    const std::array<TF_Tensor*, 2>& outputValues, size_t id = 0) const;
};
 
#else
class ChemTab : public ChemistryModel {
   public:
    inline const static std::string DENSITY_YI_DECODE_FIELD = "DENSITY_YI_DECODE";
    static inline const std::string errorMessage = "Using the ChemTab requires Tensorflow to be compile with ABLATE.";
    ChemTab(std::filesystem::path path) : ChemistryModel("ablate::chemistry::ChemTabModel") { throw std::runtime_error(errorMessage); }
 
    [[nodiscard]] const std::vector<std::string>& GetSpeciesVariables() const override { throw std::runtime_error(errorMessage); }
 
    [[nodiscard]] const std::vector<std::string>& GetSpeciesNames() const { throw std::runtime_error(errorMessage); }
 
    [[nodiscard]] const std::vector<std::string>& GetFieldFunctionProperties() const override { throw std::runtime_error(errorMessage); }
 
    [[nodiscard]] const std::vector<std::string>& GetProgressVariables() const override { throw std::runtime_error(errorMessage); }
 
    [[nodiscard]] std::vector<std::string> GetFieldTags() const override { throw std::runtime_error(errorMessage); }
 
    std::shared_ptr<SourceCalculator> CreateSourceCalculator(const std::vector<domain::Field>& fields, const ablate::domain::Range& cellRange) override { throw std::runtime_error(errorMessage); }
 
    void View(std::ostream& stream) const override { throw std::runtime_error(errorMessage); }
 
    [[nodiscard]] eos::ThermodynamicFunction GetThermodynamicFunction(eos::ThermodynamicProperty property, const std::vector<domain::Field>& fields) const override {
        throw std::runtime_error(errorMessage);
    }
 
    [[nodiscard]] eos::ThermodynamicTemperatureFunction GetThermodynamicTemperatureFunction(eos::ThermodynamicProperty property, const std::vector<domain::Field>& fields) const override {
        throw std::runtime_error(errorMessage);
    }
 
    [[nodiscard]] eos::EOSFunction GetFieldFunctionFunction(const std::string& field, eos::ThermodynamicProperty property1, eos::ThermodynamicProperty property2,
                                                            std::vector<std::string> otherProperties) const override {
        throw std::runtime_error(errorMessage);
    }
 
    [[nodiscard]] ThermodynamicTemperatureMassFractionFunction GetThermodynamicTemperatureMassFractionFunction(ThermodynamicProperty property,
                                                                                                               const std::vector<domain::Field>& fields) const override {
        throw std::runtime_error(errorMessage);
    }
    std::map<std::string, double> GetSpeciesMolecularMass() const override { throw std::runtime_error(errorMessage); }
    std::map<std::string, std::map<std::string, int>> GetSpeciesElementalInformation() const override { throw std::runtime_error(errorMessage); }
    std::map<std::string, double> GetElementInformation() const override { throw std::runtime_error(errorMessage); }
 
    void ChemistrySource(PetscReal density, const PetscReal densityProgressVariable[], PetscReal* densityEnergySource, PetscReal* progressVariableSource) const {
        throw std::runtime_error(errorMessage);
    }
 
    void ComputeProgressVariables(const std::vector<PetscReal>& massFractions, std::vector<PetscReal>& progressVariables) const { throw std::runtime_error(errorMessage); }
 
    void ComputeMassFractions(const std::vector<PetscReal>& progressVariables, std::vector<PetscReal>& massFractions, PetscReal density = 1.0) const { throw std::runtime_error(errorMessage); }
 
    void ComputeMassFractions(const PetscReal* progressVariables, PetscReal* massFractions, PetscReal density = 1.0) const { throw std::runtime_error(errorMessage); }
 
    void GetInitializerProgressVariables(const std::string& name, std::vector<PetscReal>& progressVariables) const { throw std::runtime_error(errorMessage); }
 
    [[nodiscard]] std::vector<std::tuple<ablate::solver::CellSolver::SolutionFieldUpdateFunction, void*, std::vector<std::string>>> GetSolutionFieldUpdates() override {
        throw std::runtime_error(errorMessage);
    }
};
#endif
}  // namespace ablate::eos
#endif  // ABLATELIBRARY_CHEMTAB_HPP