Particle.h

Go to the documentation of this file.

#pragma once
 
#include "objects/containers/FlatMap.h"
#include "objects/utility/Dynamic.h"
#include "system/Settings.h"
 
NAMESPACE_SPH_BEGIN
 
class Storage;
enum class QuantityId;
 
class Particle {
    friend struct ParticleVisitor;
 
private:
    Size idx;
 
    struct InternalQuantityData {
        Dynamic value;
        Dynamic dt;
        Dynamic d2t;
    };
 
    FlatMap<QuantityId, InternalQuantityData> quantities;
 
    FlatMap<BodySettingsId, Dynamic> material;
 
public:
    Particle() = default;
 
    explicit Particle(const Size idx)
        : idx(idx) {}
 
    Particle(const Storage& storage, const Size idx);
 
    Particle(const QuantityId id, const Dynamic& value, const Size idx);
 
    Particle(const Particle& other);
 
    Particle(Particle&& other);
 
    Particle& operator=(const Particle& other);
 
    Particle& operator=(Particle&& other);
 
    Particle& addValue(const QuantityId id, const Dynamic& value);
 
    Particle& addDt(const QuantityId id, const Dynamic& value);
 
    Particle& addD2t(const QuantityId id, const Dynamic& value);
 
    Particle& addParameter(const BodySettingsId id, const Dynamic& value);
 
    INLINE Size getIndex() const {
        return idx;
    }
 
    Dynamic getValue(const QuantityId id) const;
 
    Dynamic getDt(const QuantityId id) const;
 
    Dynamic getD2t(const QuantityId id) const;
 
    Dynamic getParameter(const BodySettingsId id) const;
 
    struct QuantityData {
 
        QuantityId id;
 
        DynamicId type;
 
        Dynamic value;
 
        Dynamic dt;
 
        Dynamic d2t;
    };
 
    class QuantityIterator {
    private:
        using ActIterator = Iterator<const FlatMap<QuantityId, InternalQuantityData>::Element>;
 
        ActIterator iter;
 
    public:
        QuantityIterator(const ActIterator iterator, Badge<Particle>);
 
        QuantityIterator& operator++();
 
        QuantityData operator*() const;
 
        bool operator!=(const QuantityIterator& other) const;
    };
 
    class QuantitySequence {
    private:
        QuantityIterator first;
        QuantityIterator last;
 
    public:
        QuantitySequence(const Particle& particle);
 
        QuantityIterator begin() const;
 
        QuantityIterator end() const;
    };
 
    QuantitySequence getQuantities() const;
 
    struct ParamData {
 
        BodySettingsId id;
 
        Dynamic value;
    };
 
    class ParamIterator {
    private:
        using ActIterator = Iterator<const FlatMap<BodySettingsId, Dynamic>::Element>;
 
        ActIterator iter;
 
    public:
        ParamIterator(const ActIterator iterator, Badge<Particle>);
 
        ParamIterator& operator++();
 
        ParamData operator*() const;
 
        bool operator!=(const ParamIterator& other) const;
    };
 
    class ParamSequence {
    private:
        ParamIterator first;
        ParamIterator last;
 
    public:
        ParamSequence(const Particle& particle);
 
        ParamIterator begin() const;
 
        ParamIterator end() const;
    };
 
    ParamSequence getParameters() const;
};
 
NAMESPACE_SPH_END