cell_chemistry.h

Go to the documentation of this file.

 
#ifndef CELL_CHEMISTRY_H
#define CELL_CHEMISTRY_H
 
#include <cstdint>
#include <memory>
 
#include <Kokkos_Core.hpp>
 
#include "kinetics.h"
#include "mixture.h"
#include "reactor.h"
#include "sparse_lu.h"
#include "state.h"
 
struct CellChemistryOptions {
    chemistry::ReactorOptions reactor;
    double T_frozen = 0.0;
    uint32_t lanes = 0;
    uint32_t threads = 0;
    int shared = 0;
    bool bin_by_cost = true;
    bool forced = false;  // calls may take a ChemistryForcing
};
 
struct ChemistryForcing {
    State rate;
    State scratch;
};
 
struct ChemistryCells {
    StateView U;
    SpeciesView rhoY;
    Kokkos::View<rtype *> T_seed;
    Kokkos::View<rtype *> chem_h;
    Kokkos::View<rtype *> chem_cost;
    Kokkos::View<float *> previous_cost;
    Kokkos::View<rtype *> time_scale;
    SpeciesView rate;
    StateView U_end;
    SpeciesView rhoY_end;
 
    bool forced() const { return U_end.extent(0) > 0; }
};
 
class ChemistryBalance;
 
class CellChemistry {
    public:
        void init(const Mixture & gas, const chemistry::Mechanism & mechanism,
                  const chemistry::KineticsTable<> & kinetics, const CellChemistryOptions & options,
                  uint32_t n_cells);
 
        struct Statistics {
            uint64_t active = 0;    // cells that needed chemistry
            uint32_t failures = 0;  // cells whose integration here failed (sent cells: where they ran)
            uint64_t sent = 0;      // active cells integrated by another rank
        };
 
        void balance_across_ranks(double threshold);
 
        Statistics advance(const StateView & U, const SpeciesView & rhoY, const Kokkos::View<rtype *> & T_seed,
                           const Kokkos::View<rtype *> & chem_h, const Kokkos::View<rtype *> & chem_cost, uint32_t n,
                           double dt, const Kokkos::View<rtype *> & time_scale = {},
                           const ChemistryForcing * forcing = nullptr);
 
        void heat_release(const StateView & U, const SpeciesView & rhoY, const Kokkos::View<rtype *> & T_seed,
                          const Kokkos::View<rtype *> & hrr, const Kokkos::View<rtype **, Kokkos::LayoutRight> & production,
                          uint32_t n);
 
        uint32_t lanes() const { return n_lanes; }
 
        uint32_t threads() const { return n_threads; }
 
        uint32_t wide_threads() const { return n_wide_threads; }
 
        bool binned() const { return bin_by_cost; }
 
        size_t shared_bytes() const { return fast_bytes; }
 
        uint32_t sparse_entries() const { return sparse ? pattern.nnz : 0; }
 
    private:
        uint32_t integrate(const ChemistryCells & cells, const Kokkos::View<uint32_t *> & queued,
                           const Kokkos::View<float *> & queued_cost, uint32_t n, double dt);
 
        std::shared_ptr<ChemistryBalance> balance;
        Mixture gas;
        chemistry::KineticsTable<> kinetics;
        CellChemistryOptions options;
        uint32_t n_lanes = 1;
        uint32_t n_threads = 1;
        uint32_t n_wide_threads = 0;  // threads of the expensive cells' teams, 0: the same teams for all
        Kokkos::DefaultExecutionSpace narrow_space, wide_space;
        Kokkos::View<uint32_t> team_failures[2];  // failures of the narrow and wide teams
        bool bin_by_cost = false;
        size_t fast_bytes = 0;
        bool sparse = false;
        uint32_t forcing_offset = 0;  // of the forcing in a cell's work memory, 0: none
        chemistry::SparseLUPattern<> pattern;
        Kokkos::View<double **, Kokkos::LayoutRight> work;  // (cell of a chunk, work)
        Kokkos::View<uint32_t **, Kokkos::LayoutRight> pivot;
        Kokkos::View<uint32_t *> active, queue;  // (cell): flags, then the cells that need chemistry
        Kokkos::View<float *> cost;  // binning: minus the last cost of each queued cell
        Kokkos::View<float *> previous_cost;  // (cell)
};
 
#endif // CELL_CHEMISTRY_H