Boundary.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/ForwardDecl.h"
#include "objects/containers/Array.h"
#include "objects/geometry/Domain.h"
#include "objects/geometry/Vector.h"
#include "objects/wrappers/AutoPtr.h"
#include "objects/wrappers/Interval.h"
#include "quantities/Storage.h"
#include <set>
 
NAMESPACE_SPH_BEGIN
 
class ISymmetricFinder;
 
class IBoundaryCondition : public Polymorphic {
public:
    virtual void initialize(Storage& storage) = 0;
 
    virtual void finalize(Storage& storage) = 0;
};
 
struct NullBoundaryCondition : public IBoundaryCondition {
    virtual void initialize(Storage& UNUSED(storage)) override {}
    virtual void finalize(Storage& UNUSED(storage)) override {}
};
 
class GhostParticlesData : public IStorageUserData {
private:
    Array<Ghost> ghosts;
 
public:
    explicit GhostParticlesData(Array<Ghost>&& ghosts)
        : ghosts(std::move(ghosts)) {}
 
    Ghost& getGhost(const Size idx) {
        return ghosts[idx];
    }
 
    Size size() const {
        return ghosts.size();
    }
};
 
class GhostParticles : public IBoundaryCondition {
public:
    static constexpr Size FLAG = Size(-1);
 
private:
    Array<Ghost> ghosts;
    Array<Size> ghostIdxs;
    SharedPtr<IDomain> domain;
 
    struct {
        Float searchRadius;
        Float minimalDist;
    } params;
 
    Function<Optional<Vector>(const Vector& r)> ghostVelocity;
 
    Size particleCnt;
 
public:
    GhostParticles(SharedPtr<IDomain> domain, const Float searchRadius, const Float minimalDist);
 
    GhostParticles(SharedPtr<IDomain> domain, const RunSettings& settings);
 
    void setVelocityOverride(Function<Optional<Vector>(const Vector& r)> ghostVelocity);
 
    virtual void initialize(Storage& storage) override;
 
    virtual void finalize(Storage& storage) override;
};
 
class FixedParticles : public IBoundaryCondition {
public:
    struct Params {
        AutoPtr<IDomain> domain;
 
        AutoPtr<IDistribution> distribution;
 
        AutoPtr<IMaterial> material;
 
        Float thickness = NAN;
    };
 
private:
    Storage fixedParticles;
 
public:
    FixedParticles(const RunSettings& settings, Params&& params);
 
    virtual void initialize(Storage& storage) override;
 
    virtual void finalize(Storage& storage) override;
};
 
 
class FrozenParticles : public IBoundaryCondition {
protected:
    SharedPtr<IDomain> domain;
    Float radius;
 
    std::set<Size> frozen;
 
    Array<Float> distances;
    Array<Size> idxs;
 
public:
    FrozenParticles();
 
    ~FrozenParticles();
 
    FrozenParticles(SharedPtr<IDomain> domain, const Float radius);
 
    void freeze(const Size flag);
 
    void thaw(const Size flag);
 
    virtual void initialize(Storage& UNUSED(storage)) override {}
 
    virtual void finalize(Storage& storage) override;
};
 
 
class WindTunnel : public FrozenParticles {
public:
    WindTunnel(SharedPtr<IDomain> domain, const Float radius);
 
    virtual void initialize(Storage& UNUSED(storage)) override {}
 
    virtual void finalize(Storage& storage) override;
};
 
class PeriodicBoundary : public IBoundaryCondition {
private:
    Box domain;
 
    Array<Ghost> ghosts;
    Array<Size> ghostIdxs;
 
public:
    explicit PeriodicBoundary(const Box& domain);
 
    virtual void initialize(Storage& storage) override;
 
    virtual void finalize(Storage& storage) override;
};
 
class SymmetricBoundary : public IBoundaryCondition {
private:
    Array<Ghost> ghosts;
    Array<Size> ghostIdxs;
 
public:
    virtual void initialize(Storage& storage) override;
 
    virtual void finalize(Storage& storage) override;
};
 
class KillEscapersBoundary : public IBoundaryCondition {
private:
    SharedPtr<IDomain> domain;
 
public:
    explicit KillEscapersBoundary(SharedPtr<IDomain> domain);
 
    virtual void initialize(Storage& storage) override;
 
    virtual void finalize(Storage& storage) override;
};
 
class Projection1D : public IBoundaryCondition {
private:
    Interval domain;
    ArrayView<Vector> r, v;
 
public:
    explicit Projection1D(const Interval& domain);
 
    virtual void initialize(Storage& UNUSED(storage)) override {}
 
    virtual void finalize(Storage& storage) override;
};
 
 
NAMESPACE_SPH_END