Column.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/utility/Dynamic.h"
#include "quantities/Quantity.h"
#include "quantities/QuantityIds.h"
#include "quantities/Storage.h"
#include "system/Statistics.h"
 
NAMESPACE_SPH_BEGIN
 
class ITextColumn : public Polymorphic {
public:
    virtual Dynamic evaluate(const Storage& storage,
        const Statistics& stats,
        const Size particleIdx) const = 0;
 
    virtual void accumulate(Storage& storage, const Dynamic value, const Size particleIdx) const = 0;
 
    virtual std::string getName() const = 0;
 
    virtual ValueEnum getType() const = 0;
};
 
 
template <typename TValue>
class ValueColumn : public ITextColumn {
private:
    QuantityId id;
 
public:
    explicit ValueColumn(const QuantityId id)
        : id(id) {}
 
    virtual Dynamic evaluate(const Storage& storage,
        const Statistics& UNUSED(stats),
        const Size particleIdx) const override {
        ArrayView<const TValue> values = storage.getValue<TValue>(id);
        if (particleIdx >= values.size()) {
            throw Exception("Cannot evaluate value of particle " + std::to_string(particleIdx) +
                            ", storage only contains " + std::to_string(values.size()) + " particles");
        }
        return values[particleIdx];
    }
 
    virtual void accumulate(Storage& storage, const Dynamic value, const Size particleIdx) const override {
        if (!storage.has(id)) {
            // lazy initialization
            storage.insert<TValue>(id, OrderEnum::ZERO, TValue(0._f));
        }
        Array<TValue>& array = storage.getValue<TValue>(id);
        array.resize(particleIdx + 1); 
        array[particleIdx] = value.get<TValue>();
    }
 
    virtual std::string getName() const override {
        return getMetadata(id).quantityName;
    }
 
    virtual ValueEnum getType() const override {
        return GetValueEnum<TValue>::type;
    }
};
 
template <typename TValue>
class DerivativeColumn : public ITextColumn {
private:
    QuantityId id;
 
public:
    explicit DerivativeColumn(const QuantityId id)
        : id(id) {}
 
    virtual Dynamic evaluate(const Storage& storage,
        const Statistics& UNUSED(stats),
        const Size particleIdx) const override {
        ArrayView<const TValue> values = storage.getDt<TValue>(id);
        if (particleIdx >= values.size()) {
            throw Exception("Cannot evaluate derivative of particle " + std::to_string(particleIdx) +
                            ", storage only contains " + std::to_string(values.size()) + " particles");
        }
        return values[particleIdx];
    }
 
    virtual void accumulate(Storage& storage, const Dynamic value, const Size particleIdx) const override {
        if (!storage.has(id)) {
            // lazy initialization
            storage.insert<TValue>(id, OrderEnum::FIRST, TValue(0._f));
        } else if (storage.getQuantity(id).getOrderEnum() == OrderEnum::ZERO) {
            // has the quantity, but not derivatives; we need to resize it manually to side-step the check
            // of equality in Storage::insert.
            storage.getQuantity(id).setOrder(OrderEnum::FIRST);
        }
        Array<TValue>& array = storage.getDt<TValue>(id);
        array.resize(particleIdx + 1);
        array[particleIdx] = value.get<TValue>();
    }
 
    virtual std::string getName() const override {
        return getMetadata(id).derivativeName;
    }
 
    virtual ValueEnum getType() const override {
        return GetValueEnum<TValue>::type;
    }
};
 
template <typename TValue>
class SecondDerivativeColumn : public ITextColumn {
private:
    QuantityId id;
 
public:
    explicit SecondDerivativeColumn(const QuantityId id)
        : id(id) {}
 
    virtual Dynamic evaluate(const Storage& storage,
        const Statistics& UNUSED(stats),
        const Size particleIdx) const override {
        ArrayView<const TValue> values = storage.getD2t<TValue>(id);
        if (particleIdx >= values.size()) {
            throw Exception("Cannot evaluate 2nd derivative of particle " + std::to_string(particleIdx) +
                            ", storage only contains " + values.size() + " particles");
        }
        return values[particleIdx];
    }
 
    virtual void accumulate(Storage& storage, const Dynamic value, const Size particleIdx) const override {
        if (!storage.has(id)) {
            // lazy initialization
            storage.insert<TValue>(id, OrderEnum::SECOND, TValue(0._f));
        } else if (storage.getQuantity(id).getOrderEnum() < OrderEnum::SECOND) {
            // has the quantity, but not derivatives; we need to resize it manually to side-step the check
            // of equality in Storage::insert.
            storage.getQuantity(id).setOrder(OrderEnum::SECOND);
        }
        Array<TValue>& array = storage.getD2t<TValue>(id);
        array.resize(particleIdx + 1);
        array[particleIdx] = value.get<TValue>();
    }
 
    virtual std::string getName() const override {
        return getMetadata(id).secondDerivativeName;
    }
 
    virtual ValueEnum getType() const override {
        return GetValueEnum<TValue>::type;
    }
};
 
class SmoothingLengthColumn : public ITextColumn {
public:
    virtual Dynamic evaluate(const Storage& storage,
        const Statistics& UNUSED(stats),
        const Size particleIdx) const override {
        ArrayView<const Vector> values = storage.getValue<Vector>(QuantityId::POSITION);
        if (particleIdx >= values.size()) {
            throw Exception("Cannot evaluate smoothing length of particle " + std::to_string(particleIdx) +
                            ", storage only contains " + std::to_string(values.size()) + " particles");
        }
        return values[particleIdx][H];
    }
 
    virtual void accumulate(Storage& storage, const Dynamic value, const Size particleIdx) const override {
        if (!storage.has(QuantityId::POSITION)) {
            // lazy initialization
            storage.insert<Vector>(QuantityId::POSITION, OrderEnum::SECOND, Vector(0._f));
        }
        Array<Vector>& array = storage.getValue<Vector>(QuantityId::POSITION);
        array.resize(particleIdx + 1);
        array[particleIdx][H] = value.get<Float>();
    }
 
    virtual std::string getName() const override {
        return "Smoothing length";
    }
 
    virtual ValueEnum getType() const override {
        return ValueEnum::SCALAR;
    }
};
 
template <typename TValue>
class DamageColumn : public ITextColumn {
public:
    virtual Dynamic evaluate(const Storage& storage,
        const Statistics& UNUSED(stats),
        const Size particleIdx) const override {
        ArrayView<const TValue> values = storage.getValue<TValue>(QuantityId::DAMAGE);
        if (particleIdx >= values.size()) {
            throw Exception("Cannot evaluate damage of particle " + std::to_string(particleIdx) +
                            ", storage only contains " + values.size() + " particles");
        }
        return pow<3>(values[particleIdx]);
    }
 
    virtual void accumulate(Storage& storage, const Dynamic value, const Size particleIdx) const override {
        Array<TValue>& array = storage.getValue<TValue>(QuantityId::DAMAGE);
        array.resize(particleIdx + 1);
        array[particleIdx] = root<3>(value.get<TValue>());
    }
 
    virtual std::string getName() const override {
        return "Damage";
    }
 
    virtual ValueEnum getType() const override {
        return ValueEnum::SCALAR;
    }
};
 
class ParticleNumberColumn : public ITextColumn {
public:
    virtual Dynamic evaluate(const Storage& UNUSED(storage),
        const Statistics& UNUSED(stats),
        const Size particleIdx) const override {
        return particleIdx;
    }
 
    virtual void accumulate(Storage&, const Dynamic, const Size) const override {
        // do nothing
    }
 
    virtual std::string getName() const override {
        return "Particle index";
    }
 
    virtual ValueEnum getType() const override {
        return ValueEnum::INDEX;
    }
};
 
class TimeColumn : public ITextColumn {
public:
    virtual Dynamic evaluate(const Storage& UNUSED(storage),
        const Statistics& stats,
        const Size UNUSED(particleIdx)) const override {
        return stats.get<Float>(StatisticsId::RUN_TIME);
    }
 
    virtual void accumulate(Storage&, const Dynamic, const Size) const override {
        // do nothing
    }
 
    virtual std::string getName() const override {
        return "Time";
    }
 
    virtual ValueEnum getType() const override {
        return ValueEnum::SCALAR;
    }
};
 
 
NAMESPACE_SPH_END