Integrals.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/ForwardDecl.h"
#include "math/Means.h"
#include "objects/containers/Array.h"
#include "objects/utility/Dynamic.h"
#include "objects/wrappers/Function.h"
#include "quantities/QuantityIds.h"
#include "system/Settings.h"
 
NAMESPACE_SPH_BEGIN
 
template <typename Type>
class IIntegral : public Polymorphic {
public:
    virtual Type evaluate(const Storage& storage) const = 0;
 
    virtual std::string getName() const = 0;
};
 
 
class TotalMass : public IIntegral<Float> {
public:
    virtual Float evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        return "Total mass";
    }
};
 
class TotalMomentum : public IIntegral<Vector> {
private:
    Vector omega;
 
public:
    explicit TotalMomentum(const Float omega = 0._f);
 
    virtual Vector evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        return "Total momentum";
    }
};
 
class TotalAngularMomentum : public IIntegral<Vector> {
private:
    Vector frameFrequency;
 
public:
    explicit TotalAngularMomentum(const Float frameFrequency = 0._f);
 
    virtual Vector evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        return "Total angular momentum";
    }
};
 
class TotalKineticEnergy : public IIntegral<Float> {
private:
    Vector omega;
 
public:
    explicit TotalKineticEnergy(const Float omega = 0._f);
 
    virtual Float evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        return "Kinetic energy";
    }
};
 
class TotalInternalEnergy : public IIntegral<Float> {
public:
    virtual Float evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        return "Internal energy";
    }
};
 
class TotalEnergy : public IIntegral<Float> {
private:
    Vector omega;
 
public:
    explicit TotalEnergy(const Float omega = 0._f);
 
    virtual Float evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        return "Total energy";
    }
};
 
class CenterOfMass : public IIntegral<Vector> {
private:
    Optional<Size> bodyId;
 
public:
    explicit CenterOfMass(const Optional<Size> bodyId = NOTHING);
 
    virtual Vector evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        return "Center of mass";
    }
};
 
class IUserQuantity : public Polymorphic {
public:
    virtual void initialize(const Storage& storage) = 0;
 
    virtual Float evaluate(const Size i) const = 0;
 
    virtual std::string name() const = 0;
};
 
class QuantityMeans : public IIntegral<MinMaxMean> {
private:
    Variant<QuantityId, AutoPtr<IUserQuantity>> quantity;
    Optional<Size> bodyId;
 
public:
    explicit QuantityMeans(const QuantityId id, const Optional<Size> bodyId = NOTHING);
 
    explicit QuantityMeans(AutoPtr<IUserQuantity>&& func, const Optional<Size> bodyId = NOTHING);
 
    virtual MinMaxMean evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        if (auto id = quantity.tryGet<QuantityId>()) {
            return getMetadata(id.value()).quantityName;
        } else {
            return quantity.get<AutoPtr<IUserQuantity>>()->name();
        }
    }
};
 
class QuantityValue : public IIntegral<Float> {
private:
    QuantityId id;
    Size idx;
 
public:
    QuantityValue(const QuantityId id, const Size particleIdx);
 
    virtual Float evaluate(const Storage& storage) const override;
 
    virtual std::string getName() const override {
        return getMetadata(id).quantityName + " " + std::to_string(idx);
    }
};
 
class IntegralWrapper : public IIntegral<Float> {
private:
    Function<Dynamic(const Storage& storage)> closure;
 
    std::string name;
 
public:
    IntegralWrapper() = default;
 
    template <typename TIntegral>
    IntegralWrapper(AutoPtr<TIntegral>&& integral) {
        name = integral->getName();
        closure = [i = std::move(integral)](
                      const Storage& storage) -> Dynamic { return i->evaluate(storage); };
    }
 
    virtual Float evaluate(const Storage& storage) const override {
        return closure(storage).getScalar();
    }
 
    virtual std::string getName() const override {
        return name;
    }
};
 
NAMESPACE_SPH_END