EnergyConservingSolver.h

Go to the documentation of this file.

#pragma once
 
#include "objects/finders/NeighbourFinder.h"
#include "sph/solvers/AsymmetricSolver.h"
#include "system/Statistics.h"
 
NAMESPACE_SPH_BEGIN
 
template <typename T>
class GravitySolver;
 
class IEnergyPartitioner : public Polymorphic {
public:
    virtual void initialize(const Storage& storage) = 0;
 
    virtual void compute(const Size i,
        ArrayView<const Size> neighs,
        ArrayView<const Float> e,
        ArrayView<Float> f) const = 0;
};
 
class AccelerationSeparatingHolder : public DerivativeHolder {
private:
    FlatSet<RawPtr<IAcceleration>> accelerations;
 
public:
    virtual void require(AutoPtr<IDerivative>&& derivative) override {
        RawPtr<IAcceleration> a = dynamicCast<IAcceleration>(derivative.get());
        if (a) {
            accelerations.insert(a);
        }
        DerivativeHolder::require(std::move(derivative));
    }
 
    void evalAccelerations(const Size idx,
        ArrayView<const Size> neighs,
        ArrayView<const Vector> grads,
        Array<Vector>& dv) const {
        dv.fill(Vector(0._f));
        for (auto& a : accelerations) {
            a->evalAcceleration(idx, neighs, grads, dv);
        }
    }
};
 
class EnergyConservingSolver : public IAsymmetricSolver {
    friend class GravitySolver<EnergyConservingSolver>;
 
private:
    AccelerationSeparatingHolder derivatives;
 
    Float initialDt;
 
    AutoPtr<IEnergyPartitioner> partitioner;
 
    struct ThreadData {
        Array<NeighbourRecord> neighs;
 
        Array<Float> energyChange;
 
        Array<Float> partitions;
 
        Array<Vector> accelerations;
    };
 
    ThreadLocal<ThreadData> threadData;
 
    Array<Array<Size>> neighList;
 
    Array<Array<Vector>> gradList;
 
public:
    EnergyConservingSolver(IScheduler& scheduler, const RunSettings& settings, const EquationHolder& eqs);
 
    EnergyConservingSolver(IScheduler& scheduler,
        const RunSettings& settings,
        const EquationHolder& eqs,
        AutoPtr<IBoundaryCondition>&& bc);
 
private:
    virtual void sanityCheck(const Storage& storage) const override;
 
    virtual void beforeLoop(Storage& storage, Statistics& stats) override;
 
    virtual void loop(Storage& storage, Statistics& stats) override;
 
    virtual void afterLoop(Storage& storage, Statistics& stats) override;
};
 
NAMESPACE_SPH_END