NeighbourFinder.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/ArrayView.h"
#include "objects/finders/Order.h"
#include "objects/geometry/Vector.h"
#include "objects/wrappers/Flags.h"
 
NAMESPACE_SPH_BEGIN
 
class IScheduler;
 
struct NeighbourRecord {
    Size index;
 
    Float distanceSqr;
 
    bool operator!=(const NeighbourRecord& other) const {
        return index != other.index || distanceSqr != other.distanceSqr;
    }
 
    bool operator<(const NeighbourRecord& other) const {
        return distanceSqr < other.distanceSqr;
    }
};
 
class IBasicFinder : public Polymorphic {
protected:
    ArrayView<const Vector> values;
 
public:
    void build(IScheduler& scheduler, ArrayView<const Vector> points);
 
    virtual Size findAll(const Size index, const Float radius, Array<NeighbourRecord>& neighbours) const = 0;
 
    virtual Size findAll(const Vector& pos, const Float radius, Array<NeighbourRecord>& neighbours) const = 0;
 
protected:
    virtual void buildImpl(IScheduler& scheduler, ArrayView<const Vector> points) = 0;
};
 
enum class FinderFlag {
    MAKE_RANK = 1 << 0,
 
    SKIP_RANK = 0,
};
 
template <typename TCompare>
static Order makeRank(const Size size, TCompare&& comp) {
    Order tmp(size);
    // sort using the given comparator
    tmp.shuffle(comp);
    // invert to get the rank
    return tmp.getInverted();
}
 
class ISymmetricFinder : public IBasicFinder {
protected:
    Order rank;
 
public:
    void build(IScheduler& scheduler,
        ArrayView<const Vector> points,
        Flags<FinderFlag> flags = FinderFlag::MAKE_RANK);
 
    template <typename TCompare>
    void buildWithRank(IScheduler& scheduler, ArrayView<const Vector> points, TCompare&& comp) {
        values = points;
        rank = makeRank(values.size(), comp);
        this->buildImpl(scheduler, values);
    }
 
    virtual Size findLowerRank(const Size index,
        const Float radius,
        Array<NeighbourRecord>& neighbours) const = 0;
};
 
template <typename TDerived>
class FinderTemplate : public ISymmetricFinder {
public:
    virtual Size findAll(const Size index,
        const Float radius,
        Array<NeighbourRecord>& neighbours) const override {
        neighbours.clear();
        return static_cast<const TDerived*>(this)->template find<true>(
            values[index], index, radius, neighbours);
    }
 
    virtual Size findAll(const Vector& pos,
        const Float radius,
        Array<NeighbourRecord>& neighbours) const override {
        neighbours.clear();
        if (SPH_UNLIKELY(values.empty())) {
            return 0._f;
        }
        // the index here is irrelevant, so let's use something that would cause assert in case we messed
        // something up
        const Size index = values.size();
        return static_cast<const TDerived*>(this)->template find<true>(pos, index, radius, neighbours);
    }
 
    virtual Size findLowerRank(const Size index,
        const Float radius,
        Array<NeighbourRecord>& neighbours) const override {
        neighbours.clear();
        return static_cast<const TDerived*>(this)->template find<false>(
            values[index], index, radius, neighbours);
    }
};
 
NAMESPACE_SPH_END