Storage.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/ForwardDecl.h"
#include "objects/Exceptions.h"
#include "objects/containers/Array.h"
#include "objects/containers/FlatMap.h"
#include "objects/wrappers/Flags.h"
#include "objects/wrappers/Function.h"
#include "objects/wrappers/Outcome.h"
#include "objects/wrappers/SharedPtr.h"
#include "quantities/QuantityIds.h"
 
NAMESPACE_SPH_BEGIN
 
class IMaterial;
class Quantity;
class Box;
class StorageSequence;
class ConstStorageSequence;
enum class OrderEnum;
enum class VisitorEnum;
 
 
struct StorageElement {
    QuantityId id;
    Quantity& quantity;
};
 
struct ConstStorageElement {
    QuantityId id;
    const Quantity& quantity;
};
 
class StorageIterator {
private:
    using ActIterator = Iterator<FlatMap<QuantityId, Quantity>::Element>;
 
    ActIterator iter;
 
public:
    StorageIterator(const ActIterator iterator, Badge<StorageSequence>);
 
    StorageIterator& operator++();
 
    StorageElement operator*();
 
    bool operator==(const StorageIterator& other) const;
 
    bool operator!=(const StorageIterator& other) const;
};
 
class ConstStorageIterator {
private:
    using ActIterator = Iterator<const FlatMap<QuantityId, Quantity>::Element>;
 
    ActIterator iter;
 
public:
    ConstStorageIterator(const ActIterator iterator, Badge<ConstStorageSequence>);
 
    ConstStorageIterator& operator++();
 
    ConstStorageElement operator*();
 
    bool operator==(const ConstStorageIterator& other) const;
 
    bool operator!=(const ConstStorageIterator& other) const;
};
 
class StorageSequence {
private:
    FlatMap<QuantityId, Quantity>& quantities;
 
public:
    StorageSequence(FlatMap<QuantityId, Quantity>& quantities, Badge<Storage>);
 
    StorageIterator begin();
 
    StorageIterator end();
 
    Size size() const;
};
 
class ConstStorageSequence {
private:
    const FlatMap<QuantityId, Quantity>& quantities;
 
public:
    ConstStorageSequence(const FlatMap<QuantityId, Quantity>& quantities, Badge<Storage>);
 
    ConstStorageIterator begin();
 
    ConstStorageIterator end();
 
    Size size() const;
};
 
class IStorageUserData : public Polymorphic {};
 
class InvalidStorageAccess : public Exception {
public:
    explicit InvalidStorageAccess(const QuantityId id);
 
    explicit InvalidStorageAccess(const std::string& message);
};
 
class Storage : public Noncopyable {
private:
    FlatMap<QuantityId, Quantity> quantities;
 
    struct MatRange {
        SharedPtr<IMaterial> material;
 
        Size from = 0;
 
        Size to = 0;
 
        MatRange() = default;
 
        MatRange(const SharedPtr<IMaterial>& material, const Size from, const Size to);
    };
 
    Array<MatRange> mats;
 
    ArrayView<Size> matIds;
 
    Array<WeakPtr<Storage>> dependent;
 
    SharedPtr<IStorageUserData> userData;
 
public:
    Storage();
 
    explicit Storage(const SharedPtr<IMaterial>& material);
 
    ~Storage();
 
    Storage(Storage&& other);
 
    Storage& operator=(Storage&& other);
 
    bool has(const QuantityId key) const;
 
    template <typename TValue>
    bool has(const QuantityId key, const OrderEnum order) const;
 
    Quantity& getQuantity(const QuantityId key);
 
    const Quantity& getQuantity(const QuantityId key) const;
 
    template <typename TValue>
    StaticArray<Array<TValue>&, 3> getAll(const QuantityId key);
 
    template <typename TValue>
    StaticArray<const Array<TValue>&, 3> getAll(const QuantityId key) const;
 
    template <typename TValue>
    Array<TValue>& getValue(const QuantityId key);
 
    template <typename TValue>
    const Array<TValue>& getValue(const QuantityId key) const;
 
    template <typename TValue>
    Array<TValue>& getDt(const QuantityId key);
 
    template <typename TValue>
    const Array<TValue>& getDt(const QuantityId key) const;
 
    template <typename TValue>
    Array<TValue>& getD2t(const QuantityId key);
 
    template <typename TValue>
    const Array<TValue>& getD2t(const QuantityId key) const;
 
    template <typename TValue, typename... TArgs>
    auto getValues(const QuantityId first, const QuantityId second, const TArgs... others) {
        return tie(getValue<TValue>(first), getValue<TValue>(second), getValue<TValue>(others)...);
    }
 
    template <typename TValue, typename... TArgs>
    auto getValues(const QuantityId first, const QuantityId second, const TArgs... others) const {
        // better not const_cast here as we are deducing return type
        return tie(getValue<TValue>(first), getValue<TValue>(second), getValue<TValue>(others)...);
    }
 
    template <typename TValue>
    Quantity& insert(const QuantityId key, const OrderEnum order, const TValue& defaultValue);
 
    template <typename TValue>
    Quantity& insert(const QuantityId key, const OrderEnum order, Array<TValue>&& values);
 
    void addDependent(const WeakPtr<Storage>& other);
 
    MaterialView getMaterial(const Size matIdx) const;
 
    MaterialView getMaterialOfParticle(const Size particleIdx) const;
 
    void setMaterial(const Size matIdx, const SharedPtr<IMaterial>& material);
 
    Interval getRange(const QuantityId id, const Size matIdx) const;
 
    template <typename TValue>
    Array<TValue> getMaterialParams(const BodySettingsId param) const;
 
    bool isHomogeneous(const BodySettingsId param) const;
 
    StorageSequence getQuantities();
 
    ConstStorageSequence getQuantities() const;
 
    void propagate(const Function<void(Storage& storage)>& functor);
 
    Size getMaterialCnt() const;
 
    Size getQuantityCnt() const;
 
    Size getParticleCnt() const;
 
    bool empty() const;
 
    void merge(Storage&& other);
 
    void zeroHighestDerivatives();
 
    enum class IndicesFlag {
        INDICES_SORTED = 1 << 0,
    };
 
    Array<Size> duplicate(ArrayView<const Size> idxs, const Flags<IndicesFlag> flags = EMPTY_FLAGS);
 
    void remove(ArrayView<const Size> idxs, const Flags<IndicesFlag> flags = EMPTY_FLAGS);
 
    void removeAll();
 
    Storage clone(const Flags<VisitorEnum> buffers) const;
 
    enum class ResizeFlag {
        KEEP_EMPTY_UNCHANGED = 1 << 0,
    };
 
    void resize(const Size newParticleCnt, const Flags<ResizeFlag> flags = EMPTY_FLAGS);
 
    void swap(Storage& other, const Flags<VisitorEnum> flags);
 
    enum class ValidFlag {
        COMPLETE = 1 << 0,
    };
 
    Outcome isValid(const Flags<ValidFlag> flags = ValidFlag::COMPLETE) const;
 
    void setUserData(SharedPtr<IStorageUserData> newData);
 
    SharedPtr<IStorageUserData> getUserData() const;
 
private:
    void addMissingBuffers(const Storage& source);
 
    void update();
};
 
Box getBoundingBox(const Storage& storage, const Float radius = 2._f);
 
Vector getCenterOfMass(const Storage& storage);
 
void setPersistentIndices(Storage& storage);
 
NAMESPACE_SPH_END