xref: /dports/science/opensph/sph-7de6c044339f649e3d19e61f735a6a24572b792a/core/quantities/Particle.cpp

#include "quantities/Particle.h"
#include "quantities/Quantity.h"
#include "quantities/Storage.h"

NAMESPACE_SPH_BEGIN

struct ParticleVisitor {
    FlatMap<QuantityId, Particle::InternalQuantityData>& data;

    template <typename TValue>
    void visit(const QuantityId id, const Quantity& q, const Size idx) {
        const auto& values = q.getAll<TValue>();
        switch (q.getOrderEnum()) {
        case OrderEnum::SECOND:
            data[id].d2t = values[2][idx];
            SPH_FALLTHROUGH
        case OrderEnum::FIRST:
            data[id].dt = values[1][idx];
            SPH_FALLTHROUGH
        case OrderEnum::ZERO:
            data[id].value = values[0][idx];
            break;
        default:
            NOT_IMPLEMENTED;
        }
    }
};


Particle::Particle(const Storage& storage, const Size idx)
    : idx(idx) {
    for (ConstStorageElement i : storage.getQuantities()) {
        quantities.insert(i.id, InternalQuantityData{});

        ParticleVisitor visitor{ quantities };
        dispatch(i.quantity.getValueEnum(), visitor, i.id, i.quantity, idx);
    }
}

Particle::Particle(const QuantityId id, const Dynamic& value, const Size idx)
    : idx(idx) {
    quantities.insert(id, InternalQuantityData{});
    quantities[id].value = value;
}

Particle::Particle(const Particle& other) {
    *this = other;
}

Particle::Particle(Particle&& other) {
    *this = std::move(other);
}

Particle& Particle::operator=(const Particle& other) {
    quantities = other.quantities.clone();
    material = other.material.clone();
    idx = other.idx;
    return *this;
}

Particle& Particle::operator=(Particle&& other) {
    quantities = std::move(other.quantities);
    material = std::move(other.material);
    idx = other.idx;
    return *this;
}

Particle& Particle::addValue(const QuantityId id, const Dynamic& value) {
    if (!quantities.contains(id)) {
        quantities.insert(id, InternalQuantityData{});
    }
    quantities[id].value = value;
    return *this;
}

Particle& Particle::addDt(const QuantityId id, const Dynamic& value) {
    if (!quantities.contains(id)) {
        quantities.insert(id, InternalQuantityData{});
    }
    quantities[id].dt = value;
    return *this;
}

Particle& Particle::addD2t(const QuantityId id, const Dynamic& value) {
    if (!quantities.contains(id)) {
        quantities.insert(id, InternalQuantityData{});
    }
    quantities[id].d2t = value;
    return *this;
}

Particle& Particle::addParameter(const BodySettingsId id, const Dynamic& value) {
    if (!material.contains(id)) {
        material.insert(id, NOTHING);
    }
    material[id] = value;
    return *this;
}


Dynamic Particle::getValue(const QuantityId id) const {
    Optional<const InternalQuantityData&> quantity = quantities.tryGet(id);
    SPH_ASSERT(quantity);
    return quantity->value;
}

Dynamic Particle::getDt(const QuantityId id) const {
    Optional<const InternalQuantityData&> quantity = quantities.tryGet(id);
    SPH_ASSERT(quantity);
    return quantity->dt;
}

Dynamic Particle::getD2t(const QuantityId id) const {
    Optional<const InternalQuantityData&> quantity = quantities.tryGet(id);
    SPH_ASSERT(quantity);
    return quantity->d2t;
}

Dynamic Particle::getParameter(const BodySettingsId id) const {
    Optional<const Dynamic&> value = material.tryGet(id);
    SPH_ASSERT(value);
    return value.value();
}


Particle::QuantityIterator::QuantityIterator(const ActIterator iterator, Badge<Particle>)
    : iter(iterator) {}

Particle::QuantityIterator& Particle::QuantityIterator::operator++() {
    ++iter;
    return *this;
}

Particle::QuantityData Particle::QuantityIterator::operator*() const {
    const InternalQuantityData& internal = iter->value();
    DynamicId type;
    if (internal.value) {
        type = internal.value.getType();
        SPH_ASSERT(internal.dt.empty() || internal.dt.getType() == type);
        SPH_ASSERT(internal.d2t.empty() || internal.d2t.getType() == type);
    } else if (internal.dt) {
        type = internal.dt.getType();
        SPH_ASSERT(internal.d2t.empty() || internal.d2t.getType() == type);
    } else {
        SPH_ASSERT(internal.d2t);
        type = internal.d2t.getType();
    }
    return { iter->key(), type, internal.value, internal.dt, internal.d2t };
}

bool Particle::QuantityIterator::operator!=(const QuantityIterator& other) const {
    return iter != other.iter;
}

Particle::QuantitySequence::QuantitySequence(const Particle& particle)
    : first(particle.quantities.begin(), {})
    , last(particle.quantities.end(), {}) {}

Particle::QuantityIterator Particle::QuantitySequence::begin() const {
    return first;
}

Particle::QuantityIterator Particle::QuantitySequence::end() const {
    return last;
}

Particle::QuantitySequence Particle::getQuantities() const {
    return QuantitySequence(*this);
}


Particle::ParamIterator::ParamIterator(const ActIterator iterator, Badge<Particle>)
    : iter(iterator) {}

Particle::ParamIterator& Particle::ParamIterator::operator++() {
    ++iter;
    return *this;
}

Particle::ParamData Particle::ParamIterator::operator*() const {
    return { iter->key(), iter->value() };
}

bool Particle::ParamIterator::operator!=(const ParamIterator& other) const {
    return iter != other.iter;
}


Particle::ParamSequence::ParamSequence(const Particle& particle)
    : first(particle.material.begin(), {})
    , last(particle.material.end(), {}) {}

Particle::ParamIterator Particle::ParamSequence::begin() const {
    return first;
}

Particle::ParamIterator Particle::ParamSequence::end() const {
    return last;
}

Particle::ParamSequence Particle::getParameters() const {
    return ParamSequence(*this);
}

NAMESPACE_SPH_END