Derivative.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/FlatSet.h"
#include "objects/geometry/Vector.h"
#include "quantities/Storage.h"
#include "sph/equations/Accumulated.h"
#include "system/Profiler.h"
#include "system/Settings.h"
#include <typeinfo>
 
NAMESPACE_SPH_BEGIN
 
 
enum class DerivativePhase {
    PRECOMPUTE,
 
    EVALUATION,
};
 
class IDerivative : public Polymorphic {
public:
    virtual void create(Accumulated& results) = 0;
 
    virtual void initialize(const Storage& input, Accumulated& results) = 0;
 
    virtual void evalNeighs(const Size idx, ArrayView<const Size> neighs, ArrayView<const Vector> grads) = 0;
 
    virtual DerivativePhase phase() const = 0;
 
    virtual bool equals(const IDerivative& other) const {
        return typeid(*this) == typeid(other);
    }
};
 
class ISymmetricDerivative : public IDerivative {
public:
    virtual void evalSymmetric(const Size idx,
        ArrayView<const Size> neighs,
        ArrayView<const Vector> grads) = 0;
 
    virtual DerivativePhase phase() const final {
        return DerivativePhase::EVALUATION;
    }
};
 
class IAcceleration : public ISymmetricDerivative {
public:
    virtual void evalAcceleration(const Size idx,
        ArrayView<const Size> neighs,
        ArrayView<const Vector> grads,
        ArrayView<Vector> dv) = 0;
};
 
 
class CorrectionTensor final : public IDerivative {
private:
    ArrayView<const Vector> r;
    ArrayView<const Size> idxs;
    ArrayView<const Float> reduce;
    ArrayView<const Float> m, rho;
    ArrayView<SymmetricTensor> C;
 
    bool sumOnlyUndamaged;
 
public:
    explicit CorrectionTensor(const RunSettings& settings);
 
    virtual void create(Accumulated& results) override;
 
    virtual void initialize(const Storage& input, Accumulated& results) override;
 
    virtual void evalNeighs(Size i, ArrayView<const Size> neighs, ArrayView<const Vector> grads) override;
 
    virtual DerivativePhase phase() const override;
};
 
 
class DerivativeHolder : public Polymorphic {
private:
    Accumulated accumulated;
 
    struct Less {
        INLINE bool operator()(const AutoPtr<IDerivative>& d1, const AutoPtr<IDerivative>& d2) const {
            if (d1->phase() != d2->phase()) {
                // sort primarily by phases
                return d1->phase() < d2->phase();
            }
            // used sorting of pointers for order within the same phase
            return &*d1 < &*d2;
        }
    };
 
    FlatSet<AutoPtr<IDerivative>, Less> derivatives;
 
    bool needsCreate = true;
 
public:
    virtual void require(AutoPtr<IDerivative>&& derivative);
 
    virtual void initialize(const Storage& input);
 
    void eval(const Size idx, ArrayView<const Size> neighs, ArrayView<const Vector> grads);
 
    void evalSymmetric(const Size idx, ArrayView<const Size> neighs, ArrayView<const Vector> grads);
 
    bool isSymmetric() const;
 
    INLINE Accumulated& getAccumulated() {
        return accumulated;
    }
 
    INLINE Size getDerivativeCnt() const {
        return derivatives.size();
    }
};
 
NAMESPACE_SPH_END