Distribution.h

Go to the documentation of this file.

#pragma once
 
 
#include "math/rng/Rng.h"
#include "objects/containers/Array.h"
#include "objects/wrappers/Flags.h"
#include "objects/wrappers/Function.h"
 
NAMESPACE_SPH_BEGIN
 
class IDomain;
class IScheduler;
 
class IDistribution : public Polymorphic {
public:
    virtual Array<Vector> generate(IScheduler& scheduler, const Size n, const IDomain& domain) const = 0;
};
 
class RandomDistribution : public IDistribution {
private:
    AutoPtr<IRng> rng;
 
public:
    explicit RandomDistribution(AutoPtr<IRng>&& rng);
 
    explicit RandomDistribution(const Size seed);
 
    virtual Array<Vector> generate(IScheduler& scheduler, const Size n, const IDomain& domain) const override;
};
 
class StratifiedDistribution : public IDistribution {
private:
    AutoPtr<IRng> rng;
 
public:
    explicit StratifiedDistribution(const Size seed);
 
    virtual Array<Vector> generate(IScheduler& scheduler, const Size n, const IDomain& domain) const override;
};
 
class CubicPacking : public IDistribution {
public:
    virtual Array<Vector> generate(IScheduler& scheduler, const Size n, const IDomain& domain) const override;
};
 
class HexagonalPacking : public IDistribution {
public:
    enum class Options {
        SORTED = 1 << 0,
 
        CENTER = 1 << 1,
 
        SPH5_COMPATIBILITY = 1 << 2
    };
 
private:
    Flags<Options> flags;
 
    Function<bool(Float)> progressCallback;
 
public:
    explicit HexagonalPacking(const Flags<Options> flags = Options::CENTER);
 
    HexagonalPacking(const Flags<Options> flags, Function<bool(Float)> progressCallback);
 
    virtual Array<Vector> generate(IScheduler& scheduler, const Size n, const IDomain& domain) const override;
};
 
struct DiehlParams {
    using DensityFunc = Function<Float(const Vector& position)>;
 
    DensityFunc particleDensity = [](const Vector&) { return 1._f; };
 
    Size maxDifference = 10;
 
    Size numOfIters = 50;
 
    Float strength = 0.1_f;
 
    Float small = 0.1_f;
 
    Function<bool(Size iter, ArrayView<const Vector> r)> onIteration = nullptr;
};
 
class DiehlDistribution : public IDistribution {
private:
    DiehlParams params;
 
public:
    explicit DiehlDistribution(const DiehlParams& params);
 
    virtual Array<Vector> generate(IScheduler& scheduler, const Size n, const IDomain& domain) const override;
};
 
class ParametrizedSpiralingDistribution : public IDistribution {
private:
    Size seed;
 
public:
    explicit ParametrizedSpiralingDistribution(const Size seed);
 
    virtual Array<Vector> generate(IScheduler& scheduler, const Size n, const IDomain& domain) const override;
};
 
class LinearDistribution : public IDistribution {
public:
    virtual Array<Vector> generate(IScheduler& scheduler, const Size n, const IDomain& domain) const override;
};
 
NAMESPACE_SPH_END