docs/api/solver_8h_source.html

#ifndef SOLVER_H

#define SOLVER_H


#include <array>

#include <fstream>

#include <functional>

#include <limits>

#include <memory>

#include <string>

#include <vector>


#include <toml.hpp>


#include "mesh.h"

#include "boundary.h"

#include "face_reconstruction.h"

#include "riemann_solver.h"

#include "time_integrator.h"

#include "physics.h"

#include "les.h"

#include "pasr.h"

#include "tfles.h"

#include "mixture.h"

#include "cell_chemistry.h"

#include "radiation.h"

#include "scalar_reconstruction.h"

#include "data_writer.h"

#include "statistics.h"

#include "synthetic_inflow.h"

#include "expression.h"

#include "comm.h"

#include "distributed_mesh.h"

#include "distribution.h"

#include "halo_exchange.h"

#include "log.h"


struct ForceMonitor {

    std::string zone;

    std::string file;

    Kokkos::View<uint32_t *> faces;

    uint64_t interval = 1;

    std::shared_ptr<std::ofstream> out;

};


constexpr int N_FLOW_STATISTICS = 9;


struct IntegralMonitor {

    uint64_t interval = 0;

    std::string file;

    std::shared_ptr<std::ofstream> out;

    bool budget = false;  // also the kinetic-energy budget (Solver::kinetic_energy_budget)

};


struct KineticEnergyBudget {

    rtype convective = 0.0;

    rtype viscous = 0.0;

    rtype sgs = 0.0;

    rtype pressure_work = 0.0;  // the convective rate of a scheme without numerical dissipation

};


struct DirichletBoundary {

    std::vector<uint32_t> faces;

    std::vector<Expression> W;

};


class Solver {

    public:

        Solver();

        ~Solver();


        int init(const std::string & input_file_name);


        int init(const toml::value & input);


        int run();


        void take_step();


        void calc_rhs(State solution, State rhs, rtype t);


        rtype calc_dt_cfl1(Kokkos::View<rtype> on_device = {});


        void update_primitives();


        void update_p_max();


        void copy_device_to_host();


        void copy_host_to_device();


        std::array<rtype, 2 * N_DIM> calc_force(const Kokkos::View<uint32_t *> & faces);


        std::array<rtype, N_CONSERVATIVE> integrate_conservatives();


        std::vector<rtype> integrate_species();


        std::array<rtype, N_FLOW_STATISTICS> integrate_flow_statistics();


        void update_velocity_gradients();


        void update_vortex_fields();


        // Public because nvcc rejects device lambdas in non-public member functions

        void update_average_pressure_outlets(StateView solution);

        void add_mass_flow_force(StateView solution, StateView rhs);

        void update_characteristic_boundaries(rtype t_stage);

        RestartFaces characteristic_restart_faces() const;

        void restore_characteristic_state(const RestartData & restart);

        uint64_t restart_face_key(uint32_t i_face) const;

        void apply_sponges(const State & solution, const State & rhs);

        void calc_dt();

        rtype next_target_time() const;

        void check_fields();


        // A whole step (calc_dt and take_step) as one CUDA graph; see solver_graph.cpp

        std::string step_graph_unsupported() const;

        void graph_step();

        void record_step();

        void destroy_step_graph();

        void calc_rhs_mixture(State solution, State rhs, rtype t);

        void add_geometric_source(StateView rhs, Kokkos::View<rtype *, Kokkos::LayoutStride> mu);

        void update_primitives_mixture();

        void init_temperature_seed();

        rtype calc_dt_cfl1_mixture();

        void freeze_thermodynamics();

        void reset_energy();

        std::array<rtype, 6> mixture_diagnostics();

        void update_cell_states(const State & solution, bool update_seed);

        void update_transport();

        void update_eddy_viscosity(uint32_t n);

        void eddy_viscosity_of_state(uint32_t n);

        void update_thickened_flame();

        void update_partially_stirred_reactor();

        void update_dynamic_constant();

        void thicken_transport();

        void exchange_cell_vectors(const Kokkos::View<rtype *[3]> & v);


        void init_chemistry();

        void allocate_chemistry();

        void advance_chemistry(double dt_chem);

        void take_simpler_step();

        void subtract_transport_rate(const State & rhs);

        void check_chemistry(const CellChemistry::Statistics & stats, double start);

        void update_heat_release_rate();

        std::pair<uint64_t, double> chemistry_statistics();


        KineticEnergyBudget kinetic_energy_budget();

        rtype les_constant() const { return les.C; }

        double les_dynamic_ratio() const { return dynamic_ratio; }


        bool is_les() const { return les_on; }

        const LES & get_les() const { return les; }

        const Kokkos::View<rtype *[3]>::host_mirror_type & get_les_coefficients() const { return h_les_coefficients; }

        const Kokkos::View<rtype *>::host_mirror_type & get_chem_time_scale() const { return h_chem_time_scale; }

        const Kokkos::View<rtype *[3]>::host_mirror_type & get_tfles_fields() const { return h_tfles_fields; }

        const Kokkos::View<rtype *[3]>::host_mirror_type & get_cell_transport() const { return h_cell_transport; }


        bool is_mixture() const { return mixture_model != nullptr; }

        bool is_viscous() const { return is_mixture() ? mixture.viscous : physics.is_viscous(); }

        const MixtureModel & get_mixture() const { return *mixture_model; }


        void set_distributed(bool on) { distribute = on; }

        bool is_distributed() const { return distribute && comm::size() > 1; }


        double chemistry_cells_sent() const { return chem_cells_sent; }

        const Distribution & get_distribution() const { return distribution; }


        double get_mass_flow_force() const { return mass_flow_force; }


        rtype get_time() const { return t; }

        const Statistics & get_statistics() const { return statistics; }

        uint64_t get_step() const { return step; }

        const Euler & get_physics() const { return physics; }

        std::shared_ptr<Mesh> get_mesh() const { return mesh; }


        State state() const { return State(conservatives, species); }


        const std::vector<std::string> & get_species_names() const { return species_names; }


        StateView conservatives;

        SpeciesView species;

        Kokkos::View<rtype *[N_PRIMITIVE]> primitives;

        StateView::host_mirror_type h_conservatives;

        SpeciesView::host_mirror_type h_species;

        Kokkos::View<rtype *[N_PRIMITIVE]>::host_mirror_type h_primitives;

        Kokkos::View<rtype *> p_max;  // largest pressure of each cell so far, if P_MAX is written

        Kokkos::View<rtype *>::host_mirror_type h_p_max;

        // Q, then the vorticity (one component in 2D), if any of them is written

        Kokkos::View<rtype **> vortex_fields;

        Kokkos::View<rtype **>::host_mirror_type h_vortex_fields;


    protected:

        void init_mesh();

        void init_radiation();

        void add_radiation(StateView rhs, SpeciesView rhoY);

        void init_physics();

        void init_numerics();

        void init_boundaries();

        void init_run_parameters();

        void init_output();

        void init_solution();

        void init_solution_constant();

        void init_solution_analytical();

        void init_solution_restart();

        void update_boundary_states(rtype t_eval);

        void init_inlets(const std::vector<toml::value> & input_boundaries,

                         const std::vector<std::pair<size_t, std::vector<uint32_t>>> & inlets);

        void update_inflow(rtype t_eval);

        void init_sources();

        void update_source_field(rtype t_eval);

        void init_sponges();

        std::vector<std::vector<double>> composition_at_cells(const toml::value & table, const std::string & where,

                                                              const std::vector<uint32_t> & cells) const;

        void allocate_memory();

        void register_data();

        std::vector<std::string> restart_variables() const;  // Flow block, then RHOY_<species>

        std::string stop_reason() const;  // Empty while no stop condition holds

        bool state_needed() const;        // Whether output, checks or the end of the run read the state now

        double progress() const;          // Fraction of the run done, by the first stop condition to hit

        void print_setup() const;

        void print_progress();

        void print_summary(const std::string & stop) const;

        template <typename F>

        void timed_phase(const std::string & name, F && f);

        void write_data(bool force = false);

        void write_forces();

        void write_integrals();

        void write_probes();

        CellSampler cell_sampler() const { return CellSampler{conservatives, species, primitives}; }


    private:

        // Step graph (solver_graph.cpp)

        bool cuda_graphs = true;               // [run] cuda_graphs

        bool use_step_graph = false;

        void * step_graph_exec = nullptr;      // cudaGraphExec_t

        Kokkos::View<rtype> step_dt_cfl1;      // device: local, then global minimum

        Kokkos::View<rtype *> step_scalars;    // device: [t, t_target, dt_scales...]

        Kokkos::View<rtype *, Kokkos::SharedHostPinnedSpace> step_io;  // pinned: [t, t_target, dt]


        bool distribute = true;

        int halo_layers = 0;

        std::unique_ptr<DistributedMesh> setup;  // during init only

        std::string partitioner;

        Distribution distribution;

        HaloExchange halo;


        int base_halo_layers() const;

        bool halo_too_shallow();

        void trim_halo();

        void describe_partition_surface();

        void init_rhs_split();

        void init_axisymmetric_weights();

        void init_les();

        void update_upwind_sensor();

        rtype kinetic_energy_rate() const;

        rtype pressure_work_rate() const;


        template <typename T_riemann_solver>

        void launch_flux_functor();

        template <typename T_riemann_solver>

        void launch_mixture_flux_functor();

        template <typename T_riemann_solver>

        void launch_double_flux_functor();

        void init_mixture_boundaries(const std::vector<toml::value> & input_boundaries,

                                     const std::vector<std::array<uint32_t, 2>> & profiled_faces,

                                     std::vector<BoundaryCondition> & bcs);


        Kokkos::View<uint32_t *> rhs_cells;  // reconstructed cells, the n_early_cells independent of the halo first

        uint32_t n_early_cells = 0;

        Kokkos::View<uint32_t *> rhs_faces;  // faces of owned cells, whose fluxes are used; empty if all faces

        Kokkos::DefaultExecutionSpace overlap_space;  // runs the early cells while the halo is exchanged

        bool halo_current = false;                     // halo of conservatives filled since its last update


        toml::value input;


        // Run parameters

        uint64_t n_steps;

        rtype t_stop;

        rtype t_wall_stop;

        bool use_cfl;

        rtype dt = 0.0;

        rtype dt_fixed = 0.0;

        rtype cfl;

        rtype t;

        uint64_t step;

        Kokkos::Timer timer;

        uint64_t n_cells_global = 0;


        // Run log

        logging::Items mesh_summary;

        logging::Items boundary_summary;

        logging::Items source_summary;

        std::string initial_state;

        double t_wall_setup = 0.0;

        double t_wall_stepping = 0.0;

        double t_wall_checks = 0.0;

        double t_wall_output = 0.0;

        double t_wall_run_start = 0.0;

        double t_stepping_last_check = 0.0;

        double progress_run_start = 0.0;

        uint64_t step_run_start = 0;

        uint64_t step_last_check = 0;

        uint64_t n_progress_rows = 0;


        // Numerics and physics

        std::shared_ptr<Mesh> mesh;

        Euler physics;

        std::vector<std::string> species_names;

        std::shared_ptr<MixtureModel> mixture_model;  // null for a single gas

        Mixture mixture;

        ScalarReconstruction scalar_reconstruction;

        std::vector<std::vector<double>> bc_mass_fractions;  // per boundary condition, empty unless prescribed

        std::vector<std::array<double, 2>> bc_surrogates;    // [gamma, e0] of prescribed states

        std::vector<double> bc_temperatures;                  // T of prescribed states

        BoundaryData boundary_data;

        std::vector<DirichletBoundary> dirichlet_boundaries;

        struct AveragePressureOutlet {

            int32_t i_bc;

            Kokkos::View<uint32_t *> faces;   // Faces of owned cells

            std::vector<uint32_t> sum_order;  // Order of the gathered faces of all ranks by global key

        };

        std::vector<AveragePressureOutlet> average_pressure_outlets;

        Kokkos::View<rtype *[N_DIM + 2]>::host_mirror_type h_face_state;

        Kokkos::View<int32_t *>::host_mirror_type h_face_state_index;

        rtype t_boundary_states;

        bool boundary_states_steady = false;  // evaluated, and no expression depends on t

        std::unique_ptr<FaceReconstruction> face_reconstruction;

        RiemannSolverType riemann_solver_type;

        rtype low_mach_cutoff = 0.1_r;

        bool hybrid_flux = false;           // [numerics] convective_flux = "hybrid" (docs/design/les.md, section 4.3)

        rtype hybrid_threshold = 0.65_r;

        rtype hybrid_floor = 0.0;

        Kokkos::View<rtype *> cell_upwind;  // hybrid flux: upwind fraction of each cell, else empty

        std::unique_ptr<TimeIntegrator> time_integrator;


        // Axisymmetric runs (see docs/design/axisymmetric.md)

        bool axisymmetric = false;

        Kokkos::View<rtype *> geometric_source;  // (cell): int (p - tau_thetatheta) dA, the radial momentum source

        Kokkos::View<rtype *> cell_mu;           // (cell): viscosity, viscous single gases


        // Weights of the convective flux points, (face, q): 3D faces, and 2D Gauss

        // weights times the radius in axisymmetric runs; empty for planar 2D runs

        Kokkos::View<rtype **> flux_weights;


        // Work arrays

        Kokkos::View<rtype *[N_CONSERVATIVE]> W_cells;

        Kokkos::View<rtype **[2][N_CONSERVATIVE]> face_solution;

        Kokkos::View<rtype *[N_CONSERVATIVE]> face_flux;

        Kokkos::View<rtype *[N_CONSERVATIVE][N_DIM]> viscous_gradients;

        LSQVertexGradientFunctor viscous_gradient;  // Fills viscous_gradients from W_cells

        Kokkos::View<rtype *> cfl_local;

        Kokkos::View<rtype *>::host_mirror_type h_cfl_local;

        Kokkos::View<rtype *>::host_mirror_type h_teno_sigma;

        std::vector<State> solution_vec;

        std::vector<State> rhs_vec;

        RHSFunction rhs_func;


        // Large-eddy simulation (docs/design/les.md)

        bool les_on = false;

        LES les;

        Kokkos::View<rtype *> les_delta;               // (cell): filter width V^(1/d)

        Kokkos::View<rtype *> les_width;               // (cell): the eddy viscosity's width (les_delta or Scotti's)

        Kokkos::View<rtype *[3]> les_coefficients;     // (cell, [mu_t, lambda_t, mu_t / (Sc_t W)]), empty without LES

        Kokkos::View<rtype *[3]>::host_mirror_type h_les_coefficients;

        bool budget_pass = false;                      // calc_rhs evaluates kinetic_energy_budget

        bool tfles_on = false;                         // [les.combustion]: thickened flame

        ThickenedFlame thickened_flame;

        Kokkos::View<rtype *[3]> tfles_fields;         // (cell, [F, E, Omega])

        Kokkos::View<rtype *[3]>::host_mirror_type h_tfles_fields;

        Kokkos::View<rtype *> chem_time_scale;         // (cell): E / F or kappa, the chemistry's rate multiplier

        Kokkos::View<rtype *>::host_mirror_type h_chem_time_scale;

        bool pasr_on = false;                          // [les.combustion]: partially stirred reactor

        PartiallyStirredReactor pasr;

        Kokkos::View<rtype *[3]> tfles_vorticity;

        Kokkos::View<rtype *[3][N_DIM]> tfles_gradients;

        State tfles_halo;                              // [F, E, Omega] as species, for the halo exchange

        State dynamic_halo;                            // [rho, u] as flow, d u_i / d x_j as species, owners' values

        Kokkos::View<double *[2]> dynamic_terms;       // (owned cell, [L:M, M:M] V)

        Kokkos::View<double *[6]> dynamic_stresses;    // (cell, rho Delta^2 D(g) S^d)

        double dynamic_ratio = 0.0;

        KineticEnergyBudget budget;


        // Gas mixtures

        ScalarView cell_scalars;                              // (cell, [Y_1 .. Y_Ns, gamma, e0])

        Kokkos::View<rtype *> cell_molar_mass;                // TENO: troubled-cell indicator

        bool double_flux = false;

        bool cells_frozen = false;                            // within a double-flux step

        Kokkos::View<rtype *[2]> frozen_thermo;               // (cell, [gamma, e0]) of the step

        Kokkos::View<rtype *> face_energy_1;                  // double flux: energy flux of side 1

        Kokkos::View<rtype *> T_seed;                         // Newton seed of each cell's temperature

        Kokkos::View<rtype *>::host_mirror_type h_T_seed;

        Kokkos::View<rtype **[2][2]> face_thermo;              // (face, q, side, [gamma, e0])

        Kokkos::View<rtype **> face_mdot;                     // (face, q)

        Kokkos::View<rtype ***, Kokkos::LayoutRight> species_slots;  // (face, side, k)

        Kokkos::View<rtype *[3]> cell_transport;                     // viscous: (cell, [mu, lambda, nu_eff])

        Kokkos::View<rtype *[3]>::host_mirror_type h_cell_transport;

        Kokkos::View<double **, Kokkos::LayoutRight> cell_diffusion;  // (cell, k): rho D_k W_k / W, then D^T_k (Soret)

        Kokkos::View<rtype **, Kokkos::LayoutRight> transport_values;      // (cell, [u, T, X_1 .. X_Ns])

        Kokkos::View<rtype ***, Kokkos::LayoutRight> transport_gradients;  // (cell, variable, dimension)

        Kokkos::View<rtype **, Kokkos::LayoutRight> bc_transport_values;   // (condition, [T, X]) of UPT

        Kokkos::View<rtype **, Kokkos::LayoutRight, Kokkos::HostSpace> h_D;  // output: D_k, then D^T_k (Soret)

        Kokkos::View<rtype **, Kokkos::LayoutRight, Kokkos::HostSpace> h_Y, h_X;  // output


        // Chemistry (Strang splitting around each flow step)

        bool reacting = false;

        chemistry::ReactorOptions chemistry_options;

        double T_frozen = 0.0;

        chemistry::KineticsTable<> kinetics;

        Kokkos::View<rtype *> chem_h;     // last chemistry sub-step of each cell (restart: CHEM_H)

        Kokkos::View<rtype *>::host_mirror_type h_chem_h;

        Kokkos::View<rtype *> chem_cost;  // chemistry sub-steps of each cell in the last step

        Kokkos::View<rtype *>::host_mirror_type h_chem_cost;

        Kokkos::View<rtype *> hrr;        // heat release rate, for output

        Kokkos::View<rtype *>::host_mirror_type h_hrr;

        Kokkos::View<rtype **, Kokkos::LayoutRight> production;  // W_k omega_k, for output

        Kokkos::View<rtype **, Kokkos::LayoutRight>::host_mirror_type h_production;

        uint32_t chemistry_lanes = 0;     // vector lanes per cell, 0: automatic

        CellChemistry cell_chemistry;

        uint64_t chem_active_cells = 0;   // owned cells advanced in the last chemistry call

        double t_wall_chemistry = 0.0;

        double t_chemistry_slowest = 0.0;  // sums over chemistry calls of the slowest rank's time

        double t_chemistry_mean = 0.0;     // and of the mean of the ranks' times

        double chem_cells_integrated = 0.0, chem_cells_sent = 0.0;  // over calls and ranks; sent: load balancing

        bool chemistry_load_balance = false;

        bool fuse_chemistry = false;      // run(): fuse consecutive half steps

        bool simpler = false;             // SIMPLER balanced splitting instead of Strang

        State transport_rate;             // SIMPLER: -c = T(U^n), the transport tendency at the step's start

        bool defer_chemistry = false;     // take_step leaves its last half step pending

        double chemistry_pending = 0.0;   // chemistry time not yet applied to the state


        // Optically thin radiation ([radiation])

        bool radiating = false;

        chemistry::OpticallyThinRadiation radiation;

        Kokkos::View<rtype *, Kokkos::HostSpace> h_qrad;  // output: radiative loss [W/m^3]


        // Source terms

        bool has_gravity = false;

        rtype gravity[N_DIM] = {};

        std::vector<Expression> source_expressions;  // Per conservative variable, empty if none

        bool source_time_dependent = false;

        StateView source_field;

        StateView::host_mirror_type h_source_field;

        rtype t_source = -1.0;

        bool hold_mass_flow = false;

        double mass_flow_target = 0.0;      // volume average of rho u along the direction

        rtype mass_flow_direction[N_DIM] = {};

        double domain_volume = 0.0;

        double mass_flow_force = 0.0;


        // Sponge layers: owned cells of positive total strength sum_i sigma_i,

        // and sum_i sigma_i U_ref,i of the conservatives, then the partial densities

        Kokkos::View<uint32_t *> sponge_cells;

        Kokkos::View<rtype *> sponge_strength;

        Kokkos::View<rtype **, Kokkos::LayoutRight> sponge_target;

        rtype sponge_dt_max = std::numeric_limits<rtype>::infinity();  // 1 / max strength


        bool characteristic_transverse = false;  // Some characteristic boundary has transverse terms

        rtype t_characteristic = -1.0;           // Time the incoming waves were last advanced from

        bool characteristic_state_set = false;   // char_state holds the faces' state (from a step or a restart)

        // Synthetic turbulence of inlets, and the time of the targets in char_target

        std::vector<std::unique_ptr<SyntheticInflow>> inflows;

        rtype t_inflow = -1.0;


        // Checks

        uint32_t check_interval;

        bool check_nan;


        // Outputs

        std::vector<Data> data;

        std::vector<std::unique_ptr<DataWriter>> data_writers;

        std::vector<ForceMonitor> force_monitors;

        IntegralMonitor integral_monitor;

        Statistics statistics;

        Probes probes;

};


#endif // SOLVER_H

boundary.h
Boundary conditions.

cell_chemistry.h
Finite-rate chemistry of the cells of a mesh: each cell that needs it is an adiabatic constant-volume...

CellChemistry
Work memory and kernels that advance the cells of a state as adiabatic constant-volume reactors at fi...
Definition cell_chemistry.h:99

HaloExchange
Point-to-point exchange of per-cell state following a Distribution's plan. Buffers are packed on the ...
Definition halo_exchange.h:30

MixtureModel
Host side of the mixture gas model: the mechanism, a host copy of the thermodynamics for setup,...
Definition mixture.h:83

Probes
Point and line probes: the values of the cells holding a set of points, written every interval steps ...
Definition statistics.h:128

ScalarReconstruction
Reconstructs a mixture's cell scalars (mass fractions and the thermodynamic surrogates gamma,...
Definition scalar_reconstruction.h:103

Solver
Definition solver.h:85

Solver::is_viscous
bool is_viscous() const
Whether the flow is viscous (Navier-Stokes), for a single gas or a mixture.
Definition solver.h:333

Solver::mixture_diagnostics
std::array< rtype, 6 > mixture_diagnostics()
Over owned cells and all ranks: min rho, min p, -max Ma, min T, -max T, -max |sum Y - 1|.
Definition solver_mixture.cpp:352

Solver::add_geometric_source
void add_geometric_source(StateView rhs, Kokkos::View< rtype *, Kokkos::LayoutStride > mu)
Axisymmetric runs: add geometric_source, made high order by the reconstruction where it can (mu: cell...
Definition solver_rhs.cpp:226

Solver::write_data
void write_data(bool force=false)
Definition solver.cpp:1563

Solver::init_temperature_seed
void init_temperature_seed()
Definition solver_mixture.cpp:386

Solver::get_species_names
const std::vector< std::string > & get_species_names() const
Names of the transported species, empty for a single gas.
Definition solver.h:361

Solver::reset_energy
void reset_energy()
Definition solver_mixture.cpp:382

Solver::init_numerics
void init_numerics()
Definition solver.cpp:771

Solver::graph_step
void graph_step()
Definition solver_graph.cpp:108

Solver::restart_variables
std::vector< std::string > restart_variables() const
Definition solver.cpp:1221

Solver::init_mesh
void init_mesh()
Definition solver.cpp:198

Solver::init_radiation
void init_radiation()
Mixtures: read [radiation]; subtract the optically thin radiative loss from the energy RHS.
Definition solver_radiation.cpp:49

Solver::get_statistics
const Statistics & get_statistics() const
Definition solver.h:352

Solver::thicken_transport
void thicken_transport()
Thickened flame: multiply the transport of every cell (after update_eddy_viscosity).
Definition solver_les.cpp:645

Solver::record_step
void record_step()
Definition solver_graph.cpp:67

Solver::cell_sampler
CellSampler cell_sampler() const
Definition solver.h:414

Solver::les_constant
rtype les_constant() const
LES: the model constant in use (the dynamic procedure's latest with les.dynamic).
Definition solver.h:315

Solver::update_partially_stirred_reactor
void update_partially_stirred_reactor()
PaSR: the reacting fraction kappa of every owned cell (chem_time_scale), once per step in calc_dt.
Definition solver_les.cpp:573

Solver::update_transport
void update_transport()
Viscous mixtures, after update_cell_states: transport coefficients of every cell and the gradients of...
Definition solver_mixture.cpp:368

Solver::init
int init(const std::string &input_file_name)
Initialize the solver from an input file.
Definition solver.cpp:47

Solver::get_les
const LES & get_les() const
Definition solver.h:321

Solver::subtract_transport_rate
void subtract_transport_rate(const State &rhs)
SIMPLER: rhs -= T(U^n) on the owned cells.
Definition solver_chemistry.cpp:163

Solver::write_forces
void write_forces()
Definition solver.cpp:1879

Solver::kinetic_energy_budget
KineticEnergyBudget kinetic_energy_budget()
Rates of change of the resolved kinetic energy by the convective, viscous and SGS fluxes of the curre...
Definition solver_les.cpp:765

Solver::copy_host_to_device
void copy_host_to_device()
Copy the host mirrors to the device solution.
Definition solver.cpp:1073

Solver::register_data
void register_data()
Definition solver.cpp:1150

Solver::update_vortex_fields
void update_vortex_fields()
Q = (|Omega|^2 - |S|^2) / 2 and the vorticity of each owned cell, into vortex_fields.
Definition solver.cpp:1995

Solver::get_physics
const Euler & get_physics() const
Definition solver.h:354

Solver::get_time
rtype get_time() const
Definition solver.h:351

Solver::update_characteristic_boundaries
void update_characteristic_boundaries(rtype t_stage)
At the first stage of each step: the transverse terms of the characteristic boundaries and their inco...
Definition solver_sponge.cpp:133

Solver::add_radiation
void add_radiation(StateView rhs, SpeciesView rhoY)
Definition solver_radiation.cpp:93

Solver::vortex_fields
Kokkos::View< rtype ** > vortex_fields
Definition solver.h:372

Solver::h_primitives
Kokkos::View< rtype *[N_PRIMITIVE]>::host_mirror_type h_primitives
Definition solver.h:368

Solver::update_velocity_gradients
void update_velocity_gradients()
W = [rho, u, p] in W_cells and its gradients in viscous_gradients on the owned cells: from the recons...
Definition solver.cpp:1964

Solver::conservatives
StateView conservatives
Definition solver.h:363

Solver::stop_reason
std::string stop_reason() const
Definition solver.cpp:1332

Solver::get_chem_time_scale
const Kokkos::View< rtype * >::host_mirror_type & get_chem_time_scale() const
PaSR: the reacting fraction kappa per cell, after copy_device_to_host.
Definition solver.h:325

Solver::check_fields
void check_fields()
Definition solver.cpp:1533

Solver::set_distributed
void set_distributed(bool on)
Whether a run on several ranks splits the mesh between them (default). Call before init(); tests turn...
Definition solver.h:341

Solver::eddy_viscosity_of_state
void eddy_viscosity_of_state(uint32_t n)
LES: the eddy viscosity of the current state for the time step (owned cells) or output (all).
Definition solver_les.cpp:722

Solver::h_conservatives
StateView::host_mirror_type h_conservatives
Definition solver.h:366

Solver::get_les_coefficients
const Kokkos::View< rtype *[3]>::host_mirror_type & get_les_coefficients() const
LES: [mu_t, lambda_t, mu_t / (Sc_t W)] of each cell as of the last copy_device_to_host.
Definition solver.h:323

Solver::p_max
Kokkos::View< rtype * > p_max
Definition solver.h:369

Solver::state_needed
bool state_needed() const
Definition solver.cpp:1341

Solver::update_inflow
void update_inflow(rtype t_eval)
Definition solver_inflow.cpp:50

Solver::update_source_field
void update_source_field(rtype t_eval)
Definition solver.cpp:708

Solver::get_step
uint64_t get_step() const
Definition solver.h:353

Solver::characteristic_restart_faces
RestartFaces characteristic_restart_faces() const
The [p, u_n] of the characteristic faces of owned cells, once they hold a state.
Definition solver_sponge.cpp:163

Solver::les_dynamic_ratio
double les_dynamic_ratio() const
LES: <L:M> / <M:M> of the latest dynamic procedure, before clipping at zero.
Definition solver.h:317

Solver::init_physics
void init_physics()
Definition solver.cpp:401

Solver::species
SpeciesView species
Definition solver.h:364

Solver::update_heat_release_rate
void update_heat_release_rate()
Definition solver_chemistry.cpp:128

Solver::allocate_memory
void allocate_memory()
Definition solver.cpp:991

Solver::copy_device_to_host
void copy_device_to_host()
Copy the device solution to the host mirrors.
Definition solver.cpp:1082

Solver::init_solution
void init_solution()
Definition solver_initialize.cpp:48

Solver::allocate_chemistry
void allocate_chemistry()
Definition solver_chemistry.cpp:76

Solver::update_dynamic_constant
void update_dynamic_constant()
Global dynamic procedure: les.C from the Germano identity of the current state, summed over the domai...
Definition solver_les.cpp:594

Solver::add_mass_flow_force
void add_mass_flow_force(StateView solution, StateView rhs)
Add the uniform body force along the mass flow direction that holds the volume average of rho u at it...
Definition solver.cpp:673

Solver::chemistry_statistics
std::pair< uint64_t, double > chemistry_statistics()
Over all ranks: owned cells advanced in the last chemistry call, max sub-steps of a cell in the last ...
Definition solver_chemistry.cpp:173

Solver::timed_phase
void timed_phase(const std::string &name, F &&f)
Definition solver.cpp:52

Solver::run
int run()
Run until a stop condition is reached.
Definition solver.cpp:1263

Solver::calc_rhs_mixture
void calc_rhs_mixture(State solution, State rhs, rtype t)
Definition solver_mixture.cpp:390

Solver::is_les
bool is_les() const
Whether the run is a large-eddy simulation ([les]).
Definition solver.h:320

Solver::update_eddy_viscosity
void update_eddy_viscosity(uint32_t n)
LES: the SGS coefficients [mu_t, lambda_t, mu_t / (Sc_t W)] of cells [0, n) from the velocity gradien...
Definition solver_les.cpp:710

Solver::print_progress
void print_progress()
Definition solver.cpp:1361

Solver::is_distributed
bool is_distributed() const
Definition solver.h:342

Solver::calc_dt
void calc_dt()
Definition solver.cpp:1657

Solver::composition_at_cells
std::vector< std::vector< double > > composition_at_cells(const toml::value &table, const std::string &where, const std::vector< uint32_t > &cells) const
Mass fractions of a composition table (numbers or expressions) at the centroids of cells.
Definition solver_mixture.cpp:626

Solver::get_mixture
const MixtureModel & get_mixture() const
Definition solver.h:334

Solver::get_mesh
std::shared_ptr< Mesh > get_mesh() const
Definition solver.h:355

Solver::update_primitives
void update_primitives()
Recompute primitives from conservatives on the device.
Definition solver.cpp:1623

Solver::freeze_thermodynamics
void freeze_thermodynamics()
Double flux: freeze each cell's [gamma, e0] from the true equation of state at the start of a step,...
Definition solver_mixture.cpp:377

Solver::h_p_max
Kokkos::View< rtype * >::host_mirror_type h_p_max
Definition solver.h:370

Solver::init_sponges
void init_sponges()
Definition solver_sponge.cpp:34

Solver::get_tfles_fields
const Kokkos::View< rtype *[3]>::host_mirror_type & get_tfles_fields() const
Thickened flame: [F, E, Omega] per cell, after copy_device_to_host.
Definition solver.h:327

Solver::restart_face_key
uint64_t restart_face_key(uint32_t i_face) const
Rank-count independent key of a boundary face in restart files.
Definition solver_sponge.cpp:156

Solver::get_cell_transport
const Kokkos::View< rtype *[3]>::host_mirror_type & get_cell_transport() const
Definition solver.h:328

Solver::take_step
void take_step()
Advance the solution by one time step. With chemistry, the half step that ends it may be deferred (se...
Definition solver.cpp:1586

Solver::calc_dt_cfl1
rtype calc_dt_cfl1(Kokkos::View< rtype > on_device={})
Compute the stable time step for the current solution.
Definition solver.cpp:1753

Solver::Solver
Solver()
Definition solver.cpp:38

Solver::integrate_flow_statistics
std::array< rtype, N_FLOW_STATISTICS > integrate_flow_statistics()
Domain integrals of kinetic energy rho |u|^2 / 2, enstrophy rho |omega|^2 / 2, squared dilatation (di...
Definition solver.cpp:1984

Solver::step_graph_unsupported
std::string step_graph_unsupported() const
Definition solver_graph.cpp:46

Solver::update_average_pressure_outlets
void update_average_pressure_outlets(StateView solution)
Definition solver.cpp:720

Solver::update_thickened_flame
void update_thickened_flame()
Thickened flame: [F, E, Omega] and the chemistry time scale E / F of every cell from the current stat...
Definition solver_les.cpp:554

Solver::advance_chemistry
void advance_chemistry(double dt_chem)
Definition solver_chemistry.cpp:97

Solver::calc_force
std::array< rtype, 2 *N_DIM > calc_force(const Kokkos::View< uint32_t * > &faces)
Force exerted by the fluid on a boundary zone: pressure part [Fx, Fy] and viscous part [Fx,...
Definition solver.cpp:1853

Solver::~Solver
~Solver()
Definition solver.cpp:42

Solver::check_chemistry
void check_chemistry(const CellChemistry::Statistics &stats, double start)
Counts the active cells of a chemistry call begun at start (timer), adds its rank times to the imbala...
Definition solver_chemistry.cpp:106

Solver::restore_characteristic_state
void restore_characteristic_state(const RestartData &restart)
Takes the characteristic faces' [p, u_n] from a restart file that has every face.
Definition solver_sponge.cpp:176

Solver::chemistry_cells_sent
double chemistry_cells_sent() const
Cell integrations done by another rank than the owner so far (chemistry load balancing).
Definition solver.h:345

Solver::calc_rhs
void calc_rhs(State solution, State rhs, rtype t)
Compute dU/dt for the given conservative state at time t.
Definition solver_rhs.cpp:90

Solver::integrate_species
std::vector< rtype > integrate_species()
Partial density of each species integrated over the domain (empty for a single gas).
Definition solver_mixture.cpp:613

Solver::exchange_cell_vectors
void exchange_cell_vectors(const Kokkos::View< rtype *[3]> &v)
Overwrite the halo cells of a 3-vector cell field with their owners' values.
Definition solver_les.cpp:633

Solver::h_species
SpeciesView::host_mirror_type h_species
Definition solver.h:367

Solver::primitives
Kokkos::View< rtype *[N_PRIMITIVE]> primitives
Definition solver.h:365

Solver::init_chemistry
void init_chemistry()
Reacting mixtures: read [chemistry]; advance every owned cell that needs it as an adiabatic constant-...
Definition solver_chemistry.cpp:38

Solver::h_vortex_fields
Kokkos::View< rtype ** >::host_mirror_type h_vortex_fields
Definition solver.h:373

Solver::progress
double progress() const
Definition solver.cpp:1353

Solver::write_probes
void write_probes()
Definition solver.cpp:1580

Solver::next_target_time
rtype next_target_time() const
The time the next step must not pass: t_stop or the next time-based output.
Definition solver.cpp:1649

Solver::update_cell_states
void update_cell_states(const State &solution, bool update_seed)
Gas mixtures: W = [rho, u, p] and the scalars [Y, gamma, e0] of every cell, with the temperature foun...
Definition solver_mixture.cpp:361

Solver::init_solution_restart
void init_solution_restart()
Definition solver_initialize.cpp:69

Solver::update_boundary_states
void update_boundary_states(rtype t_eval)
Definition solver.cpp:751

Solver::state
State state() const
The solution: flow block and species partial densities.
Definition solver.h:358

Solver::get_distribution
const Distribution & get_distribution() const
Definition solver.h:346

Solver::print_summary
void print_summary(const std::string &stop) const
Definition solver.cpp:1487

Solver::is_mixture
bool is_mixture() const
Whether the gas is a mixture (a mechanism is given).
Definition solver.h:331

Solver::destroy_step_graph
void destroy_step_graph()
Definition solver_graph.cpp:164

Solver::print_setup
void print_setup() const
Definition solver.cpp:1420

Solver::calc_dt_cfl1_mixture
rtype calc_dt_cfl1_mixture()
Definition solver_mixture.cpp:578

Solver::update_primitives_mixture
void update_primitives_mixture()
Definition solver_mixture.cpp:608

Solver::update_p_max
void update_p_max()
Raise P_MAX to the current pressure (updates the primitives).
Definition solver.cpp:1640

Solver::apply_sponges
void apply_sponges(const State &solution, const State &rhs)
Adds the sponge-layer sources to the RHS per unit volume (owned cells).
Definition solver_sponge.cpp:117

Solver::init_inlets
void init_inlets(const std::vector< toml::value > &input_boundaries, const std::vector< std::pair< size_t, std::vector< uint32_t > > > &inlets)
Definition solver_inflow.cpp:16

Solver::init_solution_analytical
void init_solution_analytical()
Definition solver_initialize.cpp:416

Solver::init_solution_constant
void init_solution_constant()
Definition solver_initialize.cpp:137

Solver::take_simpler_step
void take_simpler_step()
SIMPLER balanced splitting (Wu, Ma & Ihme 2019): with c = -T(U^n), the reaction substep dU/dt = R(U) ...
Definition solver_chemistry.cpp:140

Solver::init_output
void init_output()
Definition solver.cpp:900

Solver::get_mass_flow_force
double get_mass_flow_force() const
Body force per unit volume, along the mass flow direction, of the last RHS ([source] mass_flow).
Definition solver.h:349

Solver::write_integrals
void write_integrals()
Definition solver.cpp:2024

Solver::integrate_conservatives
std::array< rtype, N_CONSERVATIVE > integrate_conservatives()
Sum of each conservative variable integrated over the domain.
Definition solver.cpp:1891

Solver::init_run_parameters
void init_run_parameters()
Definition solver.cpp:876

Solver::init_boundaries
void init_boundaries()
Definition solver.cpp:420

Solver::init_sources
void init_sources()
Definition solver.cpp:609

Statistics
Running time averages per owned cell: means of fields and covariances <a'b'> of pairs of them,...
Definition statistics.h:70

comm.h
Process-level communication: MPI when built with Mallard_ENABLE_MPI, otherwise a single-rank stub wit...

dot
KOKKOS_INLINE_FUNCTION rtype dot(const rtype *a, const rtype *b)
Compute the dot product of two arrays.
Definition common_math.h:32

rtype
float rtype
Definition common_typedef.h:39

N_DIM
#define N_DIM
Definition common_typedef.h:28

data_writer.h
Data writer class declaration.

distributed_mesh.h
Scalable setup of a distributed mesh: no rank ever holds the whole mesh.

distribution.h
A rank's share of a distributed mesh: owned cells, halo layers and the halo exchange plan.

expression.h
Host-side analytical expressions of (x, y, z, t) from input files.

face_reconstruction.h
Face reconstruction class declaration.

halo_exchange.h
Fills halo cells with their owners' values.

les.h
Subgrid-scale eddy-viscosity models of large-eddy simulation.

log.h
Console output: rank-0 info lines, aligned sections and tables, warnings and errors on stderr,...

mesh.h
Mesh class declaration.

mixture.h
Thermally perfect gas mixture: the gas model of runs with a mechanism.

comm::size
int size()
Number of processes in the world communicator.
Definition comm.cpp:182

logging::Items
std::vector< std::pair< std::string, std::string > > Items
Key-value lines of a setup section, in display order.
Definition log.h:27

pasr.h
Partially stirred reactor (PaSR) closure of the filtered reaction rates (docs/design/les....

physics.h
Physics model declaration.

radiation.h
Planck-mean absorption coefficients of the optically thin radiation model of the TNF workshop (RADCAL...

riemann_solver.h
Approximate Riemann solvers.

RiemannSolverType
RiemannSolverType
Definition riemann_solver.h:24

scalar_reconstruction.h
Reconstruction of a gas mixture's cell scalars to faces.

ScalarView
Kokkos::View< rtype **, Kokkos::LayoutRight > ScalarView
Cell scalars of a mixture: (cell, j) = Y_1 .. Y_Ns, gamma, e0.
Definition scalar_reconstruction.h:26

N_FLOW_STATISTICS
constexpr int N_FLOW_STATISTICS
Definition solver.h:56

StateView
Kokkos::View< rtype *[N_CONSERVATIVE]> StateView
Flow block [rho, rho u, rho E] per cell.
Definition state.h:23

SpeciesView
Kokkos::View< rtype **, SpeciesLayout > SpeciesView
Partial densities rho Y_k per (cell, species).
Definition state.h:37

statistics.h
In-situ running time averages and probes.

BoundaryData
Device-side lookup from faces to boundary conditions.
Definition boundary.h:229

CellChemistry::Statistics
Definition cell_chemistry.h:108

CellSampler
Cell values that statistics and probes sample, by code: 0 is RHO, 1 + i the primitive PRIMITIVE_NAMES...
Definition statistics.h:37

DirichletBoundary
Faces with a Dirichlet condition and the expressions of x, y, z, t for their exterior state W = [rho,...
Definition solver.h:80

DirichletBoundary::W
std::vector< Expression > W
Definition solver.h:82

DirichletBoundary::faces
std::vector< uint32_t > faces
Definition solver.h:81

Distribution
Local numbering: owned cells first (in global order), then halo layer 1, 2, ... Every local cell keep...
Definition distribution.h:26

Euler
Calorically perfect gas, inviscid (Euler) or viscous and heat conducting (Navier-Stokes,...
Definition physics.h:54

Euler::is_viscous
KOKKOS_INLINE_FUNCTION bool is_viscous() const
Definition physics.h:85

ForceMonitor
Definition solver.h:48

ForceMonitor::out
std::shared_ptr< std::ofstream > out
Definition solver.h:53

ForceMonitor::zone
std::string zone
Definition solver.h:49

ForceMonitor::interval
uint64_t interval
Definition solver.h:52

ForceMonitor::file
std::string file
Definition solver.h:50

ForceMonitor::faces
Kokkos::View< uint32_t * > faces
Definition solver.h:51

IntegralMonitor
Definition solver.h:58

IntegralMonitor::out
std::shared_ptr< std::ofstream > out
Definition solver.h:61

IntegralMonitor::interval
uint64_t interval
Definition solver.h:59

IntegralMonitor::file
std::string file
Definition solver.h:60

IntegralMonitor::budget
bool budget
Definition solver.h:62

KineticEnergyBudget
Rates of change of the resolved kinetic energy sum_c V rho |u|^2 / 2 caused by the convective,...
Definition solver.h:69

KineticEnergyBudget::sgs
rtype sgs
Definition solver.h:72

KineticEnergyBudget::viscous
rtype viscous
Definition solver.h:71

KineticEnergyBudget::convective
rtype convective
Definition solver.h:70

KineticEnergyBudget::pressure_work
rtype pressure_work
Definition solver.h:73

LES
Eddy viscosity nu_t = C^2 Delta^2 D(g) (Vreman: c Delta^2 D(g)) of the resolved velocity gradient g[i...
Definition les.h:40

LES::C
rtype C
Definition les.h:42

LSQVertexGradientFunctor
Gradient over all vertex neighbors plus the boundary ghost states of the cell's own boundary faces,...
Definition gradient.h:233

Mixture
Device side of the mixture gas model, captured by value in kernels.
Definition mixture.h:45

Mixture::viscous
bool viscous
Definition mixture.h:49

PartiallyStirredReactor
Each cell's rates are those of its filtered state times the reacting fraction kappa = tau_c / (tau_c ...
Definition pasr.h:32

RestartData
Contents of a restart file.
Definition data_writer.h:67

RestartFaces
Face records of a restart file (version 4): the [p, u_n] of the characteristic boundary faces (docs/d...
Definition data_writer.h:58

State
Conservative state of every cell: the flow block and the partial densities of a mixture's species....
Definition state.h:56

ThickenedFlame
Thickening F, efficiency E and flame sensor Omega of a cell. The flame is thickened by F where Omega ...
Definition tfles.h:31

chemistry::KineticsTable
Reactions of a mechanism as flat device tables (compressed rows per reaction), in MemorySpace....
Definition kinetics.h:70

chemistry::OpticallyThinRadiation
Optically thin radiative loss q = 4 sigma sum_i p_i a_i(T) (T^4 - T_amb^4), p_i the partial pressures...
Definition radiation.h:53

chemistry::ReactorOptions
Definition reactor.h:27

synthetic_inflow.h
Mean velocity of characteristic inlets, and synthetic turbulence (digital filter) superposed on it.

cells
Kokkos::View< uint32_t *, Space > cells
Definition teno_setup.cpp:682

tfles.h
Dynamically thickened flame model (TFLES) of turbulence-chemistry interaction (docs/design/les....

time_integrator.h
Time integrator class declarations.

RHSFunction
std::function< void(State solution, State rhs, rtype t)> RHSFunction
Definition time_integrator.h:43