mixture.h

Go to the documentation of this file.

 
#ifndef MIXTURE_H
#define MIXTURE_H
 
#include <map>
#include <string>
#include <vector>
 
#include <Kokkos_Core.hpp>
#include <toml.hpp>
 
#include "common.h"
#include "log.h"
#include "mechanism.h"
#include "reactor.h"
#include "state.h"
#include "thermo.h"
#include "transport.h"
 
struct PartialDensities {
    CellSpecies rhoY;
    double inv_rho;
    KOKKOS_INLINE_FUNCTION double operator()(const uint32_t k) const { return static_cast<double>(rhoY[k]) * inv_rho; }
};
 
struct Mixture {
    chemistry::ThermoTable<> thermo;
    chemistry::TransportTable<> transport;  // empty for inviscid runs
    uint32_t n_species = 0;
    bool viscous = false;
 
    KOKKOS_INLINE_FUNCTION
    void cell_state(const rtype * U, const CellSpecies & rhoY, const rtype T_guess, rtype * W, rtype & gamma, rtype & e0,
                    rtype & T) const {
        constexpr uint8_t E = N_DIM + 1;
        const double rho = static_cast<double>(U[0]);
        W[0] = U[0];
        double u2 = 0.0;
        FOR_I_DIM {
            W[1 + i] = U[1 + i] / U[0];
            u2 += static_cast<double>(U[1 + i]) * static_cast<double>(U[1 + i]);
        }
        const double e = static_cast<double>(U[E]) / rho - 0.5 * u2 / (rho * rho);
        const PartialDensities y{rhoY, 1.0 / rho};
        const double T_cell = thermo.T_from_e(e, y, static_cast<double>(T_guess));
        const double R = thermo.gas_constant(y);
        const double cv = thermo.cp_mass(T_cell, y) - R;
        W[E] = static_cast<rtype>(rho * R * T_cell);
        gamma = static_cast<rtype>((cv + R) / cv);
        e0 = static_cast<rtype>(e - cv * T_cell);
        T = static_cast<rtype>(T_cell);
    }
};
 
class MixtureModel {
    public:
        static MixtureModel from_input(const toml::value & input);
 
        const chemistry::Mechanism & mechanism() const { return mech; }
        const Mixture & device() const { return gas; }
        bool viscous() const { return gas.viscous; }
        uint32_t n_species() const { return gas.n_species; }
        std::vector<std::string> species_names() const { return mech.species_names(); }
 
        std::vector<double> mass_fractions(const toml::value & table, const std::string & where) const;
 
        static bool composition_varies(const toml::value & table);
 
        std::vector<double> mass_fractions_from_mole(const std::vector<double> & X) const;
 
        std::vector<double> mole_fractions(const std::vector<double> & Y) const;
 
        double gas_constant(const std::vector<double> & Y) const;
 
        double energy(double T, const std::vector<double> & Y) const;
 
        void surrogates(double T, const std::vector<double> & Y, double & gamma, double & e0) const;
 
        void conservatives(double p, double T, const rtype * u, const std::vector<double> & Y, rtype * U,
                           rtype * rhoY) const;
 
        logging::Items summary() const;
 
    private:
        chemistry::Mechanism mech;
        chemistry::ThermoTable<Kokkos::HostSpace> host_thermo;
        Mixture gas;
        std::string transport_name;
};
 
chemistry::ReactorOptions reactor_options(const toml::value & input);
 
#endif // MIXTURE_H