EquationTerm.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/ForwardDecl.h"
#include "objects/utility/IteratorAdapters.h"
#include "objects/wrappers/SharedPtr.h"
#include "physics/Constants.h"
#include "quantities/Storage.h"
#include <typeinfo>
 
NAMESPACE_SPH_BEGIN
 
class IEquationTerm : public Polymorphic {
public:
    virtual void setDerivatives(DerivativeHolder& derivatives, const RunSettings& settings) = 0;
 
    virtual void initialize(IScheduler& scheduler, Storage& storage, const Float t) = 0;
 
    virtual void finalize(IScheduler& scheduler, Storage& storage, const Float t) = 0;
 
    virtual void create(Storage& storage, IMaterial& material) const = 0;
};
 
class AdaptiveSmoothingLength : public IEquationTerm {
protected:
    Size dimensions;
 
    Float minimal;
 
    struct {
        Float strength;
        Interval range;
    } enforcing;
 
public:
    explicit AdaptiveSmoothingLength(const RunSettings& settings, const Size dimensions = DIMENSIONS);
 
    virtual void setDerivatives(DerivativeHolder& derivatives, const RunSettings& settings) override;
 
    virtual void initialize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void finalize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
 
private:
    void enforce(const Size i,
        ArrayView<Vector> v,
        ArrayView<const Float> cs,
        ArrayView<const Size> neighCnt);
};
 
 
class PressureForce : public IEquationTerm {
public:
    virtual void setDerivatives(DerivativeHolder& derivatives, const RunSettings& settings) override;
 
    virtual void initialize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void finalize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
};
 
class SolidStressForce : public IEquationTerm {
private:
    bool useCorrectionTensor;
 
public:
    explicit SolidStressForce(const RunSettings& settings);
 
    virtual void setDerivatives(DerivativeHolder& derivatives, const RunSettings& settings) override;
 
    virtual void initialize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void finalize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
};
 
class NavierStokesForce : public IEquationTerm {
public:
    virtual void setDerivatives(DerivativeHolder& derivatives, const RunSettings& settings) override;
 
    virtual void initialize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void finalize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
};
 
class ContinuityEquation : public IEquationTerm {
private:
    ContinuityEnum mode;
    Float w0;
 
public:
    explicit ContinuityEquation(const RunSettings& settings);
 
    virtual void setDerivatives(DerivativeHolder& derivatives, const RunSettings& settings) override;
 
    virtual void initialize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void finalize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
};
 
class ConstSmoothingLength : public IEquationTerm {
public:
    virtual void setDerivatives(DerivativeHolder& derivatives, const RunSettings& settings) override;
 
    virtual void initialize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void finalize(IScheduler& scheduler, Storage& storage, const Float t) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
};
 
 
class EquationHolder {
private:
    Array<SharedPtr<IEquationTerm>> terms;
 
public:
    EquationHolder() = default;
 
    explicit EquationHolder(const SharedPtr<IEquationTerm>& term) {
        if (term != nullptr) {
            terms.push(term);
        }
    }
 
    EquationHolder& operator+=(const EquationHolder& other) {
        terms.pushAll(other.terms);
        return *this;
    }
 
    EquationHolder operator+(const EquationHolder& other) const {
        EquationHolder holder;
        holder += *this;
        holder += other;
        return holder;
    }
 
    template <typename Term>
    bool contains() const {
        static_assert(std::is_base_of<IEquationTerm, Term>::value, "Can be used only for terms");
        for (const auto& ptr : terms) {
            IEquationTerm& term = *ptr;
            if (typeid(term) == typeid(Term)) {
                return true;
            }
        }
        return false;
    }
 
    void setDerivatives(DerivativeHolder& derivatives, const RunSettings& settings) const {
        for (const auto& term : terms) {
            term->setDerivatives(derivatives, settings);
        }
    }
 
    void initialize(IScheduler& scheduler, Storage& storage, const Float t) {
        for (const auto& term : terms) {
            term->initialize(scheduler, storage, t);
        }
    }
 
    void finalize(IScheduler& scheduler, Storage& storage, const Float t) {
        for (const auto& term : reverse(terms)) {
            term->finalize(scheduler, storage, t);
        }
    }
 
    void create(Storage& storage, IMaterial& material) const {
        for (const auto& term : terms) {
            term->create(storage, material);
        }
    }
 
    Size getTermCnt() const {
        return terms.size();
    }
};
 
template <typename Term, typename... TArgs>
INLINE EquationHolder makeTerm(TArgs&&... args) {
    return EquationHolder(makeShared<Term>(std::forward<TArgs>(args)...));
}
 
NAMESPACE_SPH_END