Quantity.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/Array.h"
#include "objects/wrappers/Flags.h"
#include "objects/wrappers/Variant.h"
#include "quantities/QuantityHelpers.h"
 
NAMESPACE_SPH_BEGIN
 
enum class OrderEnum {
    ZERO,   
    FIRST,  
    SECOND, 
};
 
 
enum class VisitorEnum {
    ZERO_ORDER = 1 << 0,
 
    FIRST_ORDER = 1 << 1,
 
    SECOND_ORDER = 1 << 2,
 
    ALL_BUFFERS = 1 << 3,
 
    ALL_VALUES = 1 << 4,
 
    STATE_VALUES = 1 << 5,
 
    HIGHEST_DERIVATIVES = 1 << 6,
};
 
 
namespace Detail {
template <typename TValue>
class Holder {
private:
    Array<TValue> v;       
    Array<TValue> dv_dt;   
    Array<TValue> d2v_dt2; 
 
    OrderEnum order;
 
    Holder(const OrderEnum order)
        : order(order) {}
 
public:
    Holder(const OrderEnum order, const TValue& defaultValue, const Size size)
        : order(order) {
        v.resize(size);
        v.fill(defaultValue);
        initDerivatives(size);
    }
 
    Holder(const OrderEnum order, Array<TValue>&& values)
        : v(std::move(values))
        , order(order) {
        initDerivatives(v.size());
    }
 
    INLINE OrderEnum getOrderEnum() const {
        return order;
    }
 
    INLINE ValueEnum getValueEnum() const {
        return GetValueEnum<TValue>::type;
    }
 
    INLINE Size size() const {
        // the quantity can be incomplete (can hold only derivatives), just return the maximum size
        return max(v.size(), dv_dt.size(), d2v_dt2.size());
    }
 
    INLINE Array<TValue>& getValue() {
        return v;
    }
 
    INLINE const Array<TValue>& getValue() const {
        return v;
    }
 
    INLINE Array<TValue>& getDt() {
        SPH_ASSERT(order == OrderEnum::FIRST || order == OrderEnum::SECOND);
        return dv_dt;
    }
 
    INLINE const Array<TValue>& getDt() const {
        SPH_ASSERT(order == OrderEnum::FIRST || order == OrderEnum::SECOND);
        return dv_dt;
    }
 
    INLINE Array<TValue>& getD2t() {
        SPH_ASSERT(order == OrderEnum::SECOND);
        return d2v_dt2;
    }
 
    INLINE const Array<TValue>& getD2t() const {
        SPH_ASSERT(order == OrderEnum::SECOND);
        return d2v_dt2;
    }
 
    INLINE StaticArray<Array<TValue>&, 3> getAll() {
        switch (order) {
        case OrderEnum::ZERO:
            return { v };
        case OrderEnum::FIRST:
            return { v, dv_dt };
        case OrderEnum::SECOND:
            return { v, dv_dt, d2v_dt2 };
        default:
            NOT_IMPLEMENTED;
        }
    }
 
    INLINE StaticArray<const Array<TValue>&, 3> getAll() const {
        switch (order) {
        case OrderEnum::ZERO:
            return { v };
        case OrderEnum::FIRST:
            return { v, dv_dt };
        case OrderEnum::SECOND:
            return { v, dv_dt, d2v_dt2 };
        default:
            NOT_IMPLEMENTED;
        }
    }
 
    Holder clone(const Flags<VisitorEnum> flags) const;
 
 
    Holder createZeros(const Size particleCnt) const;
 
    void swap(Holder& other, Flags<VisitorEnum> flags);
 
    void setOrder(const OrderEnum newOrder);
 
private:
    void initDerivatives(const Size size);
 
    template <typename TFunctor>
    void visitMutable(Holder& other, const Flags<VisitorEnum> flags, TFunctor&& functor);
 
    template <typename TFunctor>
    void visitConst(Holder& other, const Flags<VisitorEnum> flags, TFunctor&& functor) const;
};
} // namespace Detail
 
class Quantity : public Noncopyable {
private:
    template <typename... TArgs>
    using HolderVariant = Variant<NothingType, Detail::Holder<TArgs>...>;
 
    // Types must be in same order as in ValueEnum!
    using Holder = HolderVariant<Float, Vector, Tensor, SymmetricTensor, TracelessTensor, Size>;
    Holder data;
 
    Quantity(Holder&& holder)
        : data(std::move(holder)) {}
 
public:
    Quantity() = default;
 
    template <typename TValue>
    Quantity(const OrderEnum order, const TValue& defaultValue, const Size size)
        : data(Detail::Holder<TValue>(order, defaultValue, size)) {}
 
    template <typename TValue>
    Quantity(const OrderEnum order, Array<TValue>&& values)
        : data(Detail::Holder<TValue>(order, std::move(values))) {}
 
    OrderEnum getOrderEnum() const {
        return forValue(data, [](auto& holder) INL { return holder.getOrderEnum(); });
    }
 
    ValueEnum getValueEnum() const {
        SPH_ASSERT(data.getTypeIdx() != 0);
        return ValueEnum(data.getTypeIdx() - 1);
    }
 
    Quantity clone(const Flags<VisitorEnum> flags) const {
        return forValue(data, [flags](auto& holder) -> Holder { return holder.clone(flags); });
    }
 
    Quantity createZeros(const Size particleCnt) const {
        return forValue(data, [particleCnt](auto& holder) -> Holder { //
            return holder.createZeros(particleCnt);
        });
    }
 
    void swap(Quantity& other, const Flags<VisitorEnum> flags) {
        SPH_ASSERT(this->getValueEnum() == other.getValueEnum());
        forValue(data, [flags, &other](auto& holder) {
            using Type = std::decay_t<decltype(holder)>;
            return holder.swap(other.data.get<Type>(), flags);
        });
    }
 
    INLINE Size size() const {
        return forValue(data, [](auto& holder) INL { return holder.size(); });
    }
 
    template <typename TValue>
    INLINE Array<TValue>& getValue() {
        return get<TValue>().getValue();
    }
 
    template <typename TValue>
    INLINE const Array<TValue>& getValue() const {
        return get<TValue>().getValue();
    }
 
    void setOrder(const OrderEnum order) {
        return forValue(data, [order](auto& holder) INL { return holder.setOrder(order); });
    }
 
    template <typename TValue>
    INLINE Array<TValue>& getDt() {
        return get<TValue>().getDt();
    }
 
    template <typename TValue>
    INLINE const Array<TValue>& getDt() const {
        return get<TValue>().getDt();
    }
 
    template <typename TValue>
    INLINE Array<TValue>& getD2t() {
        return get<TValue>().getD2t();
    }
 
    template <typename TValue>
    INLINE const Array<TValue>& getD2t() const {
        return get<TValue>().getD2t();
    }
 
    template <typename TValue>
    StaticArray<Array<TValue>&, 3> getAll() {
        return get<TValue>().getAll();
    }
 
    template <typename TValue>
    StaticArray<const Array<TValue>&, 3> getAll() const {
        return get<TValue>().getAll();
    }
 
    template <typename TIndexSequence>
    void clamp(const TIndexSequence& sequence, const Interval range) {
        forValue(data, [&sequence, range](auto& v) {
            auto& values = v.getValue();
            for (Size idx : sequence) {
                values[idx] = Sph::clamp(values[idx], range);
            }
        });
    }
 
private:
    template <typename TValue>
    Detail::Holder<TValue>& get() {
        return data.get<Detail::Holder<TValue>>();
    }
 
    template <typename TValue>
    const Detail::Holder<TValue>& get() const {
        return data.get<Detail::Holder<TValue>>();
    }
};
 
NAMESPACE_SPH_END