AsymmetricSolver.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/geometry/Indices.h"
#include "sph/equations/Derivative.h"
#include "sph/equations/EquationTerm.h"
#include "sph/kernel/Kernel.h"
#include "thread/ThreadLocal.h"
#include "timestepping/ISolver.h"
#include <unordered_map>
 
NAMESPACE_SPH_BEGIN
 
class ISymmetricFinder;
class IBoundaryCondition;
 
class RadiiHashMap {
private:
    class IndicesEqual {
    public:
        INLINE bool operator()(const Indices& i1, const Indices& i2) const {
            return all(i1 == i2);
        }
    };
 
    std::unordered_map<Indices, Float, std::hash<Indices>, IndicesEqual> map;
    Float cellSize;
 
public:
    void build(ArrayView<const Vector> r, const Float kernelRadius);
 
    Float getRadius(const Vector& r) const;
};
 
class IAsymmetricSolver : public ISolver {
protected:
    AutoPtr<ISymmetricFinder> finder;
 
    IScheduler& scheduler;
 
    EquationHolder equations;
 
    LutKernel<DIMENSIONS> kernel;
 
    Optional<RadiiHashMap> radiiMap;
 
public:
    IAsymmetricSolver(IScheduler& scheduler, const RunSettings& settings, const EquationHolder& eqs);
 
    virtual void integrate(Storage& storage, Statistics& stats) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
 
protected:
    Float getMaxSearchRadius(const Storage& storage) const;
 
    virtual RawPtr<const IBasicFinder> getFinder(ArrayView<const Vector> r);
 
    virtual void beforeLoop(Storage& storage, Statistics& stats) = 0;
 
    virtual void loop(Storage& storage, Statistics& stats) = 0;
 
    virtual void afterLoop(Storage& storage, Statistics& stats) = 0;
 
    virtual void sanityCheck(const Storage& storage) const = 0;
};
 
class AsymmetricSolver : public IAsymmetricSolver {
protected:
    DerivativeHolder derivatives;
 
    AutoPtr<IBoundaryCondition> bc;
 
    struct ThreadData {
        Array<NeighbourRecord> neighs;
 
        Array<Size> idxs;
 
        Array<Vector> grads;
    };
 
    ThreadLocal<ThreadData> threadData;
 
public:
    AsymmetricSolver(IScheduler& scheduler, const RunSettings& settings, const EquationHolder& eqs);
 
    AsymmetricSolver(IScheduler& scheduler,
        const RunSettings& settings,
        const EquationHolder& eqs,
        AutoPtr<IBoundaryCondition>&& bc);
 
    ~AsymmetricSolver();
 
protected:
    virtual void beforeLoop(Storage& storage, Statistics& stats) override;
 
    virtual void loop(Storage& storage, Statistics& stats) override;
 
    virtual void afterLoop(Storage& storage, Statistics& stats) override;
 
    virtual void sanityCheck(const Storage& storage) const override;
};
 
NAMESPACE_SPH_END