NBodySolver.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/FlatSet.h"
#include "thread/ThreadLocal.h"
#include "timestepping/ISolver.h"
 
NAMESPACE_SPH_BEGIN
 
class ISymmetricFinder;
class ICollisionHandler;
class IOverlapHandler;
class IGravity;
struct CollisionRecord;
class CollisionStats;
enum class CollisionResult;
enum class OverlapEnum;
 
class HardSphereSolver : public ISolver {
private:
    AutoPtr<IGravity> gravity;
 
    IScheduler& scheduler;
 
    struct ThreadData {
        Array<NeighbourRecord> neighs;
 
        Array<CollisionRecord> collisions;
    };
 
    ThreadLocal<ThreadData> threadData;
 
    Array<NeighbourRecord> neighs;
 
    FlatSet<Size> removed;
 
    Array<Float> searchRadii;
 
    struct {
 
        AutoPtr<ICollisionHandler> handler;
 
        AutoPtr<ISymmetricFinder> finder;
 
    } collision;
 
    struct {
 
        AutoPtr<IOverlapHandler> handler;
 
        Float allowedRatio;
 
    } overlap;
 
    struct {
        bool use;
 
        Float maxAngle;
 
    } rigidBody;
 
    ArrayView<Vector> r;
    ArrayView<Vector> v;
 
public:
    HardSphereSolver(IScheduler& scheduler, const RunSettings& settings);
 
    HardSphereSolver(IScheduler& scheduler, const RunSettings& settings, AutoPtr<IGravity>&& gravity);
 
    HardSphereSolver(IScheduler& scheduler,
        const RunSettings& settings,
        AutoPtr<IGravity>&& gravity,
        AutoPtr<ICollisionHandler>&& collisionHandler,
        AutoPtr<IOverlapHandler>&& overlapHandler);
 
    ~HardSphereSolver() override;
 
    virtual void integrate(Storage& storage, Statistics& stats) override;
 
    virtual void collide(Storage& storage, Statistics& stats, const Float dt) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
 
private:
    void rotateLocalFrame(Storage& storage, const Float dt);
 
    enum class SearchEnum {
        FIND_LOWER_RANK,
 
        USE_RADII,
    };
 
    CollisionRecord findClosestCollision(const Size i,
        const SearchEnum opt,
        const Interval interval,
        Array<NeighbourRecord>& neighs);
 
    Optional<Float> checkCollision(const Vector& r1,
        const Vector& v1,
        const Vector& r2,
        const Vector& v2,
        const Float dt) const;
};
 
class SoftSphereSolver : public ISolver {
    AutoPtr<IGravity> gravity;
 
    IScheduler& scheduler;
 
    struct ThreadData {
        Array<NeighbourRecord> neighs;
    };
 
    ThreadLocal<ThreadData> threadData;
 
    struct {
        Float repel;
        Float friction;
    } force;
 
public:
    SoftSphereSolver(IScheduler& scheduler, const RunSettings& settings);
 
    SoftSphereSolver(IScheduler& scheduler, const RunSettings& settings, AutoPtr<IGravity>&& gravity);
 
    ~SoftSphereSolver() override;
 
    virtual void integrate(Storage& storage, Statistics& stats) override;
 
    virtual void create(Storage& storage, IMaterial& material) const override;
};
 
NAMESPACE_SPH_END