statistics.h

Go to the documentation of this file.

 
#ifndef STATISTICS_H
#define STATISTICS_H
 
#include <array>
#include <cstdint>
#include <fstream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include <Kokkos_Core.hpp>
#include <toml.hpp>
 
#include "common_typedef.h"
#include "data.h"
#include "data_writer.h"
#include "mesh.h"
#include "state.h"
 
struct CellSampler {
    StateView U;
    SpeciesView rhoY;
    Kokkos::View<rtype *[N_PRIMITIVE]> P;
 
    static constexpr int32_t RHO = 0;
    static constexpr int32_t FIRST_PRIMITIVE = 1;
    static constexpr int32_t FIRST_SPECIES = 1 + N_PRIMITIVE;
 
    KOKKOS_INLINE_FUNCTION
    rtype operator()(const uint32_t c, const int32_t code) const {
        if (code == RHO) return U(c, 0);
        if (code < FIRST_SPECIES) return P(c, code - FIRST_PRIMITIVE);
        return rhoY(c, code - FIRST_SPECIES) / U(c, 0);
    }
 
    static int32_t code(const std::string & name, const std::vector<std::string> & species_names,
                        const std::string & key);
};
 
class Statistics {
    public:
        void init(const toml::value & input, const std::vector<std::string> & species_names, uint32_t n_cells);
 
        bool enabled() const { return !fields.empty(); }
        bool due(uint64_t step, rtype t) const { return enabled() && step % interval == 0 && t > t_start; }
 
        void sample(rtype t, const CellSampler & sampler, uint32_t n_owned);
 
        std::vector<std::string> variables() const;
        void register_data(std::vector<Data> & data) const;
        void copy_device_to_host();
 
        void restore(const RestartData & restart, const std::string & file, rtype t);
        void start(rtype t);
        RestartAttributes attributes() const;
 
        std::string summary() const;
        uint64_t samples() const { return n_samples; }
        const auto & host_means() const { return h_mean; }
        const auto & host_covariances() const { return h_cov; }
 
    private:
        std::vector<std::string> fields;
        std::vector<std::pair<uint32_t, uint32_t>> products;  // indices into fields
        uint64_t interval = 1;
        rtype t_start = 0.0;
        bool reset = false;
 
        Kokkos::View<int32_t *> codes;
        Kokkos::View<uint32_t *[2]> pairs;
        Kokkos::View<rtype **, Kokkos::LayoutLeft> mean;
        Kokkos::View<rtype **, Kokkos::LayoutLeft> cov;
        Kokkos::View<rtype **, Kokkos::LayoutLeft>::host_mirror_type h_mean;
        Kokkos::View<rtype **, Kokkos::LayoutLeft>::host_mirror_type h_cov;
 
        rtype weight = 0.0;
        rtype t_last = 0.0;
        uint64_t n_samples = 0;
};
 
class Probes {
    public:
        void init(const toml::value & input, const Mesh & mesh, const std::vector<std::string> & species_names,
                  bool resume);
 
        bool due(uint64_t step) const;
        void write(uint64_t step, rtype t, const CellSampler & sampler);
 
        std::vector<std::pair<std::string, std::string>> summary() const;
        std::vector<std::string> files() const;
 
    private:
        struct Set {
            std::string name;
            std::string file;
            uint64_t interval = 1;
            std::vector<std::string> variables;
            std::vector<std::array<double, N_DIM>> points;
            std::vector<uint32_t> local_points;  // points held by owned cells of this rank
            Kokkos::View<uint32_t *> cells;      // their cells
            Kokkos::View<int32_t *> codes;
            Kokkos::View<rtype **, Kokkos::LayoutRight> values;  // (local point, variable)
            std::shared_ptr<std::ofstream> out;
        };
        std::vector<Set> sets;
};
 
std::vector<int32_t> locate_points(const Mesh & mesh, const std::vector<std::array<double, N_DIM>> & points);
 
#endif // STATISTICS_H