Statistics.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/ForwardDecl.h"
#include "math/Means.h"
#include "objects/containers/FlatMap.h"
#include "objects/utility/Dynamic.h"
#include "objects/wrappers/Interval.h"
#include "objects/wrappers/Variant.h"
#include "quantities/QuantityIds.h"
 
NAMESPACE_SPH_BEGIN
 
class Statistics {
private:
    enum Types { BOOL, INT, FLOAT, MEANS, VALUE, INTERVAL };
 
    using ValueType = Variant<bool, int, Float, MinMaxMean, Dynamic, Interval>;
 
    FlatMap<StatisticsId, ValueType> entries;
 
public:
    Statistics() = default;
 
    Statistics(const Statistics& other)
        : entries(other.entries.clone()) {}
 
    Statistics& operator=(const Statistics& other) {
        entries = other.entries.clone();
        return *this;
    }
 
    bool has(const StatisticsId idx) const {
        return entries.contains(idx);
    }
 
    template <typename TValue>
    Statistics& set(const StatisticsId idx, TValue&& value) {
        using StoreType = ConvertToSize<TValue>;
        entries.insert(idx, StoreType(std::forward<TValue>(value)));
        return *this;
    }
 
    void increment(const StatisticsId idx, const Size amount) {
        if (entries.contains(idx)) {
            entries[idx].template get<int>() += amount;
        } else {
            entries.insert(idx, int(amount));
        }
    }
 
    void accumulate(const StatisticsId idx, const Float value) {
        Optional<ValueType&> entry = entries.tryGet(idx);
        if (entry) {
            entry->template get<MinMaxMean>().accumulate(value);
        } else {
            MinMaxMean means;
            means.accumulate(value);
            entries.insert(idx, means);
        }
    }
 
 
    template <typename TValue>
    TValue get(const StatisticsId idx) const {
        Optional<const ValueType&> entry = entries.tryGet(idx);
        SPH_ASSERT(entry, int(idx));
        using StoreType = ConvertToSize<TValue>;
        const StoreType& value = entry->template get<StoreType>();
        return TValue(value);
    }
 
    template <typename TValue>
    TValue getOr(const StatisticsId idx, const TValue& other) const {
        if (this->has(idx)) {
            return this->get<TValue>(idx);
        } else {
            return other;
        }
    }
};
 
enum class StatisticsId {
    INDEX,
 
    RUN_TIME,
 
    WALLCLOCK_TIME,
 
    RELATIVE_PROGRESS,
 
    ETA,
 
    TIMESTEP_VALUE,
 
    TIMESTEP_ELAPSED,
 
    PARTICLE_COUNT,
 
    NEIGHBOUR_COUNT,
 
    SPH_EVAL_TIME,
 
    GRAVITY_BUILD_TIME,
 
    GRAVITY_NODE_COUNT,
 
    GRAVITY_NODES_EXACT,
 
    GRAVITY_NODES_APPROX,
 
    GRAVITY_EVAL_TIME,
 
    COLLISION_EVAL_TIME,
 
    POSTPROCESS_EVAL_TIME,
 
    TOTAL_COLLISION_COUNT,
 
    MERGER_COUNT,
 
    BOUNCE_COUNT,
 
    BREAKUP_COUNT,
 
    OVERLAP_COUNT,
 
    AGGREGATE_COUNT,
 
    FRAME_ANGLE,
 
    SOLVER_SUMMATION_ITERATIONS,
 
    TIMESTEP_CRITERION,
 
    LIMITING_QUANTITY,
 
    LIMITING_PARTICLE_IDX,
 
    LIMITING_VALUE,
 
    LIMITING_DERIVATIVE,
};
 
NAMESPACE_SPH_END